your goal is to complete the code in order to get

the game work there are four interfaces in the

game and 5 spaces and each space will be

revealed and display a string of letter based

on the class name here is the code :

import java.util.ArrayList;

import java.util.Collections;

import java.util.InputMismatchException;

import java.util.Random;

import java.util.Scanner;

import cmps251.homework3.Board;

import cmps251.homework3.Game;

import cmps251.homework3.Player;

/**

* DO NOT MODIFY THIS CODE

*

* This code is only to help you run the code

* You can verify the functionality by logging in to

* oryx.qu.edu.qa (ssh). A perfect solution is one that

* matches the output on the ssh server

*

*/

public class Runner {

public static void main(String[] args) {

Runner r = new Runner();

r.studentRunner();

}

private void studentRunner()

{

Scanner s = new Scanner(System.in);

System.out.print("Enter your name: ");

String name = s.nextLine();

System.out.print("Enter your age: ");

int age = s.nextInt();

s.nextLine(); //clear buffer

Player player = new Player(name, age);

ArrayList list = new ArrayList();

for (int i = 0; i

list.add(new Integer(i));

Collections.shuffle(list, new Random(System.currentTimeMillis()));

int[] rabbitPositions = {pickIndexAtRandom(list), pickIndexAtRandom(list), pickIndexAtRandom(list)};

ArrayList gluePositionsArray = new ArrayList<>();

ArrayList thornPositionsArray = new ArrayList<>();

Random a = new Random(System.currentTimeMillis());

for (int i = 0; i

if(a.nextInt(2) == 1) //flip a coin (50/50 chance) for either a Thorn or a Glue

gluePositionsArray.add(pickIndexAtRandom(list));

else thornPositionsArray.add(pickIndexAtRandom(list));

}

Game myGame = new Game(rabbitPositions, //rabbit positions

gluePositionsArray, //glue positions

thornPositionsArray, //thorn positions

pickIndexAtRandom(list), //bull position

player); //player

myGame.printStartingGreeting();

int userInput;

int thorneNum = myGame.getBoard().getNumberOfThorns();

while (!myGame.getIsGameOver())

{

userInput = -1;

System.out.println("Current Play No: " + (myGame.getPlayCount()+1));

System.out.println("Number of rabbits caught so far: " + myGame.getRabbitsCaught());

System.out.println("Number of thornes: " + thorneNum);

System.out.println("Number of glues: " + (Game.MAX_PUNISHABLES-thorneNum) +" ");

myGame.getBoard().displayBoard();

System.out.print("Please select a position ('1'-'16'): ");

while(userInput == -1)

{

try{

userInput = s.nextInt(); //a trick to find the first character of the entered string

if (userInput < 1 || userInput > 16) {

System.out.print("Not a correct input, please try again: ");

userInput = -1;

userInput = s.nextInt();

}

}catch(InputMismatchException e)

{

System.out.println("Illegal input, please try again: ");

s.next(); // clears the buffer

}

}

myGame.nextPlay(userInput);

System.out.println(" ");

}

System.out.println(" FINAL BOARD:");

myGame.getBoard().displayBoard();

System.out.println("You found all rabbits!");

System.out.println("It took you: " + myGame.getPlayCount() + " turns. Not bad for a " + myGame.getPlayer().getAge() + " year old!");

s.close();

}

private int pickIndexAtRandom(ArrayList list)

{

int out = list.get(0);

list.remove(0);

return out;

}

}

package cmps251.homework3;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Random;

import cmps251.homework3.interfaces.ResetBoard;

import cmps251.homework3.spacetypes.BullSpace;

import cmps251.homework3.spacetypes.EmptySpace;

import cmps251.homework3.spacetypes.GlueSpace;

import cmps251.homework3.spacetypes.RabbitSpace;

import cmps251.homework3.spacetypes.Space;

import cmps251.homework3.spacetypes.ThornSpace;

public class Board implements ResetBoard {

public static final int NUM_SPACES = 16;

private ArrayList mSpaces;

private Game mGame;

/**

* This constructor should initiate the state of the board with 16 different spaces

* Spaces could be RabbitSpace, BullSpace, EmptySpace, ThornSpace, or GlueSpace.

* To determine which spaces have rabbits, you should

* see the elements of the @param rabbitsPositions. So if rabbitPositions = {3, 5, 7},

* then space[3], space[5] and space[7] have rabbits in them!

*

* @param rabbitPositions an array of 3 integers with positions of the rabbits as indexes

* @param gluePositions an ArrayList of integers with positions of the glue positions as indexes (if any)

* @param thornPositions an ArrayList of integers with positions of the thorn positions as indexes (if any)

* @param bullPosition the position of the bull in the board

* @param game reference to the game object that called this constructor

*/

//TODO 10 fill in the missing parts of the constructor below

public Board(int rabbitPositions[],

ArrayList gluePositions,

ArrayList thornPositions,

int bullPosition,

Game game)

{

mSpaces = new ArrayList();

mGame = game;

//TODO 10a add to mSpaces ArrayList with 16 empty spaces (hint: use a for-loop)

//TODO 10b place the bull into the array list (hint use the ArrayList set method)

//Hint, BullSpace needs a "ResetBoard" object, this Board class implements it so you can pass "this"

//TODO 10c add the Punishable items (replace empty spaces with their corresponding Punishable)

//You may use two separate for loops. One for each positions array (thorns/glues)

//TODO 10d add the rabbits (replace empty spaces with their corresponding RabbitSpaces)

//Hint, Rabbit expects "Reset" object. Game implements Reset so you can pass the game.

}

/**

* This method prints out the board with numbers 1-16 initially

* in a 4x4 matrix.

* Once users select a number, that particular space is selected.

*

*/

public void displayBoard()

{

int sizeOfRowOrColumn = (int)Math.sqrt(mSpaces.size());

for (int i=0; i

for (int j=0; j

System.out.printf("%-7s", mSpaces.get((i*sizeOfRowOrColumn)+j).getAsString());

}

System.out.println(" ");

}

System.out.println(" ");

}

/**

* This method returns true if a rabbit exists at position "i"

* hint: use the method isRabbit inside Space.

* @param i index of space to check whether it has a rabbit or not

* @return returns true if a rabbit exists, false otherwise

*/

//TODO 05 implement the method below

public boolean getIsRabbit(int i)

{

return false; //FIXME

}

/**

* This method returns true if the space at i is revealed

*

* @param i index of space to check

* @return true if revealed, false otherwise

*

*/

public boolean isRevealed(int i)

{

return mSpaces.get(i).isRevealed();

}

/**

* Clicks on a space

* @param i the position that was selected or "clicked"

*/

public void clickSpace(int i) {

mSpaces.get(i).onClick();

}

/**

* Do not use this method in your code! You don't need it

*

* @return the array of spaces that this board has

*/

public ArrayList getSpaces() {

return mSpaces;

}

/**

* (BONUS) When the user encounters a bull, the user is knocked off and the

* rabbits run away. As such, the user must now look for the rabbits in the empty

* places again! This also means that all Empty and Rabbit spaces are reset to not revealed

*

* Keep in mind that this method is called from BullSpace's onClick().

*

* This method resets the board once a bull is encountered by the user.

* To reset the board successfully it does the following:

*

* 1- Get 3 new random rabbit positions (use getNewRabbitPositions() ).

* 2- Go over all spaces and do the following:

* a- If the space is either an EmptySpace or a RabbitSpace, then replace the space in that position

* with either a new Rabbit space, or a new Empty space depending on whether a rabbit has moved

* to this space (use the array from point 1). You can also use method "isPositionARabbit(int i)"

* below to help.

* b- If the space is anything else, leave it the way it is; this means

* that nothing changes for Bull, Thorn, and Glue spaces.

* 3- Number of caught rabbits in the game should be reset to 0 (they ran away!)

*

* At the moment, nothing is happening! It just adds more punishing points to the Game's turns

*/

//TODO 13 BONUS: implement the body of the method bullEncountered below.

@Override

public void bullEncountered()

{

Board.bullCalled = true; //DO NOT REMOVE THIS LINE!

//FIXME - type your code below this line for the bonus!

}

/**

* This method returns the number of thorns that exist in the board's spaces

*

* @return number of thorn spaces in this board

*/

//TODO 09 write the body of the function below such that it returns the number of ThornSpaces inside the Board.

public int getNumberOfThorns()

{

return 0; //FIXME

}

/**

* Simple method to check whether "position" exists in "rabbitPositions" or not.

* You can use this method to check whether one of the rabbits chose to hide in

* a given "new" position.

*

* @param position the index you are searching for

* @param rabbitPositions all the positions you are searching in

* @return true if position exists in rabbitPositions, false otherwise

*/

//TODO 06 complete this method based on the javadoc description above

protected boolean isPositionARabbit(int position, int[] rabbitPositions) {

return false; //FIXME

}

//DO NOT MODIFY ANYTHING BELOW THIS LINE

public int[] getNewRabbitPositions()

{

int [] newRabbitPositions = new int[Game.MAX_RABBITS];

ArrayList list = new ArrayList();

for (int i = 0; i

{

Space currentSpace = mSpaces.get(i);

if (currentSpace instanceof RabbitSpace ||

currentSpace instanceof EmptySpace)

list.add(mSpaces.get(i).getIndex());

}

Collections.shuffle(list, new Random(System.currentTimeMillis()));

for (int i = 0; i< Game.MAX_RABBITS; i++)

newRabbitPositions[i] = list.get(i);

return newRabbitPositions;

}

public static boolean bullCalled = false; //do not remove

}

package cmps251.homework3;

import java.util.ArrayList;

import cmps251.homework3.interfaces.Punishable;

import cmps251.homework3.interfaces.Score;

/**

* Top level class. This class keeps track of the score and status of the game so far

* It is also responsible to advance the game by implementing "nextPlay"

*

*/

//TODO 08 Implement both Punishable and Score in this class. Read the JavaDoc of the

//two interfaces to understand what to do in the method bodies exactly

public class Game {

public static final int MAX_RABBITS = 3;

public static final int MAX_PUNISHABLES = 3;

private int mRabbitsCaught = 0;

private boolean isGameOver; // true if game is over

private Board mBoard;

private Player mPlayer;

private int mPlayCount;

/**

*

* This constructor sets initial state of the game it has (board game)

*

* You should initialize all your instance variables here

*

* @param rabbitPositions an array of 3 integers that have the locations of the rabbits

* @param gluePositions an ArrayList of glue positions (if any)

* @param thornPositions an ArrayList of thorn positions (if any)

* @param bullPosition the position of the bull in the board

* @param player player to add

*/

public Game(int[] rabbitPositions,

ArrayList gluePositions,

ArrayList thornPositions,

int bullPosition,

Player player)

{

isGameOver = false;

this.mPlayer = player;

mRabbitsCaught = 0;

mPlayCount = 0;

mBoard = new Board(rabbitPositions, gluePositions, thornPositions, bullPosition, this);

}

/**

* This method prints "Hello ! Your game is starting... "

*/

public void printStartingGreeting() {

System.out.println("Hello " + mPlayer.getName() +"! ");

System.out.println("Your game is starting... ");

}

/**

* Method returns whether game is over or not (when all rabbits are revealed)

*

* @return true if game ended, false otherwise

*/

public boolean getIsGameOver()

{

return isGameOver;

}

/**

* This method advances to the next stage (turn) of the game

* It takes a number which the user selected from the board

* and updates the status of the board spaces so that this place

* on the board is clicked.

* Once all rabbits are found, it sets the game ended boolean to

* true because all rabbits are found!

*

*

* @param index the number on the board that the user selected

*/

public void nextPlay(int index)

{

index--;

if (mBoard.isRevealed(index)) //if we are already revealed.. do nothing

return;

else {

mBoard.clickSpace(index);

}

mPlayCount++;

if (mRabbitsCaught == MAX_RABBITS)

isGameOver = true;

}

/**

* Get how many turns are played so far?

*

* @return the number of times the user selected a character so far.

*/

public int getPlayCount()

{

return mPlayCount;

}

/**

* @return the Board that this game has

*/

public Board getBoard() {

return mBoard;

}

/**

* @return the Player that this game has

*/

public Player getPlayer() {

return mPlayer;

}

/**

*

* @return the number of rabbits caught so far.

*/

public int getRabbitsCaught()

{

return mRabbitsCaught;

}

}

package cmps251.homework3;

/**

* Player information class.

* A player has name and age which gets set in the constructor

*/

public class Player {

private String name;

private int age;

/**

* Constructor sets the name and age

* @param name

* @param age

*/

public Player(String name, int age)

{

this.name = name;

this.age = age;

}

/**

* Method to get name

* @return the name of the player as string

*/

public String getName()

{

return name;

}

/**

* Method to get age

* @return the age of the player as an int

*/

public int getAge()

{

return age;

}

}

package cmps251.homework3.interfaces;

public interface Clickable {

/**

* Method to process clicking on the item

*/

public void onClick();

}

package cmps251.homework3.interfaces;

public interface Punishable {

public final int PUNISHMENT_THORN = 3;

public final int PUNISHMENT_GLUE = 5;

/**

* This methods add to the play count of the game

* (the more, the worse). Implement this in Game.

*

* @param numberOfSteps number of plays to add to the total game play

*/

public void punish(int numberOfSteps);

}

package cmps251.homework3.interfaces;

public interface ResetBoard {

/**

* This method should be called when a bull is revealed!

*

* All rabbits are knocked out. Implement it in Board class

*

*/

public void bullEncountered();

}

package cmps251.homework3.interfaces;

public interface Score {

/**

* Increases the total rabbits caught by one

*/

public void increaseRabbitsCaught();

/**

* Resets the number of rabbits caught back to 0

*/

public void resetRabbitsCaught();

}

package cmps251.homework3.spacetypes;

import cmps251.homework3.interfaces.ResetBoard;

/**

* The BullSpace represents a bull. When uncovered, it should reset

* the game by making all rabbits escape and hide in new places by calling bullEncountered()

* in the ResetBoard. Hint: you will use your work from todo XX here.

*

* BullSpace is displayed as "B" when it is revealed (uncovered).

*

*

*/

//TODO 04 Fix the errors. This class is not implementing all the abstract

//methods from the superclass! Read above for hint on what your new method

//bodies should contain

public class BullSpace extends Space {

private ResetBoard mResetBoard;

public BullSpace(int index, ResetBoard resetBoard) {

super(index);

mResetBoard = resetBoard;

}

/**

* 1. Call Space's onClick (which reveals the space), then:

* 2. print out "You were knocked down by a bull!"

* 3. call mResetBoard's bullEncountered (which should be implemented in Board)

*/

//TODO 12 implement the method based on the above description

@Override

public void onClick() {

//FIXME

}

}

package cmps251.homework3.spacetypes;

/**

* EmptySpace represents an empty space that does not contain anything.

* When uncovered, it should not do anything to the game.

*

* EmptySpace is displayed as " " (empty space) when it is revealed (uncovered).

*

*/

//TODO 00 Fix the errors. This class is not implementing all the abstract

//methods from the superclass! Read above for hint on what your new method

//bodies should contain

public class EmptySpace extends Space {

public EmptySpace(int index) {

super(index);

}

}

package cmps251.homework3.spacetypes;

import cmps251.homework3.interfaces.Punishable;

/**

* GlueSpace represents glue stuck on the floor. When uncovered, glue cause the player

* to stay in the same place for a number of playCounts specified in the interface Punishable.

* Additionally, the message: "You stepped on GLUE! Yuck!" is displayed to the user.

*

* Since GlueSpace causes additional playCounts, it should use the punish method available from the mPunishable instance.

*

* GlueSpace is displayed as "G" when it is revealed (uncovered).

*

*/

//TODO 03 Fix the errors. Read above for hints on what your method bodies should be

public class GlueSpace extends Space {

Punishable mPunishable;

public GlueSpace(int index, Punishable punishable) {

super(index);

mPunishable = punishable;

}

/**

* This method is called when the Glue is clicked

* 1. It should call super class onClick (which reveals the space)

* 2. it should print out "You stepped on GLUE! Yuck!"

* 3. It should call punish() method from Punishable and pass constant (PUNISHMENT_GLUE)

* The punish method is implemented in Game and should increase the number of

* plays by PUNISHMENT_GLUE

*

* Look at the implementation of the same method in ThornSpace for hints

*/

//TODO 11 fill the body based on the above

@Override

public void onClick() {

//FIXME

}

}

package cmps251.homework3.spacetypes;

import cmps251.homework3.interfaces.Score;

/**

* RabbitSpace represents a rabbit. When uncovered (clicked), it should first

* increase the number of rabbits in the game by one (using mScore), then display the message:

* "RABBIT CAUGHT SUCCESSFULLY!"

*

* RabbitSpace is displayed as "R" when it is revealed (uncovered).

*

*/

//TODO 01 Fix the errors. Read above for hint on what your new methods' bodies should do

public class RabbitSpace extends Space {

private Score mScore;

public RabbitSpace(int index, Score score) {

super(index);

mScore = score;

}

@Override

public void onClick() {

super.onClick();

mScore.increaseRabbitsCaught();

System.out.println(" RABBIT CAUGHT SUCCESSFULLY!");

}

}

package cmps251.homework3.spacetypes;

import cmps251.homework3.interfaces.Clickable;

/**

* This abstract class is a general representation of all possible Spaces

* in the game. The types of space include:

* EmptySpace, RabbitSpace, BullSpace, ThornSpace, and GlueSpace.

*

*/

public abstract class Space implements Clickable {

private boolean isRevealed;

private int mIndex;

/**

* This constructor should initialize the space

* At the beginning, it should be not revealed, and based

* on the parameters, it should set whether it has a rabbit

* and what position in the board it currently is

*

* @param index the index (position) of this space in the board (0-16)

* @param theGame a reference to the Game object that controls the flow of the entire game

*/

public Space(int index)

{

isRevealed = false;

mIndex = index;

}

/**

*

* This method returns String representation of a space

*

* If the space is not revealed (still not chosen by the user), then it will display the

* index of the space (plus one) as a string (hint: use Integer.toString(....) )

*

* If this space is revealed, it will either return an empty space string " " for empty spaces,

* or a letter (B, R, T, or G) depending on the type of Space.

*

* You have two cases you need to take care of:

* 1. If not revealed, then print out the number of the space (hint: use Integer.toString(....) )

* 2. If revealed, it should call the abstract method getRevealedString which will be different

* for each subclass of this class.

*

* @return "0"-"16", " ", "B", "R", "T", or "G" depending on the type of Space

*/

//TODO 07 add the body of the method below by reading the above

public String getAsString(){

return ""; //FIXME

}

//DO NOT CHANGE the signature of method getRevealedString below.

/**

* @return " ", "B", "R", "T", or "G" depending on the type of Space.

*/

public abstract String getRevealedString();

/**

* This method returns whether the space has rabbit or not.

*

* @return true if this space has rabbit, false otherwise

*/

public boolean isRabbit()

{

return (this instanceof RabbitSpace);

}

/**

* This method returns whether the space is revealed or not

*

* @return true if this space is revealed, false otherwise

*/

public boolean isRevealed()

{

return isRevealed;

}

/**

* This method makes this space reveal! (show itself/unhide)

*/

private void reveal()

{

isRevealed = true;

}

/**

* @return the index position of this space in the board.

*/

public int getIndex()

{

return mIndex;

}

/**

* All spaces should be revealed regardless of type.

* Make sure you call this method from all subclasses by using super.onClick();

*/

@Override

public void onClick() {

reveal();

}

}

package cmps251.homework3.spacetypes;

import cmps251.homework3.interfaces.Punishable;

/**

* ThorneSpace represents thorns (spikes in plants). When uncovered, thornes cause the player

* to stay in the same place for a number of play counts specified in the interface Punishable.

* Additionally, the message: "You stepped on THRONES! Ouch!" is displayed to the user.

*

* Since ThornSpace causes additional playCounts, it should use the punish method available from the mPunishable instance.

*

* ThornSpace is displayed as "T" when it is revealed (uncovered).

*

*/

//TODO 02 Fix the errors. Read above for hint on what you should do in the new methods

public class ThornSpace extends Space {

private Punishable mPunishable;

public ThornSpace(int index, Punishable punishable) {

super(index);

mPunishable = punishable;

}

/**

* This method calls super classes's onClick() which reveals the space

* Then it prints out You stepped on THORNS! Ouch!

* Then it punishes the user by incrementing the number of plays so far by PUNISHTMENT_THORN

*/

@Override

public void onClick() {

super.onClick();

System.out.println(" You stepped on THRONS! Ouch!");

mPunishable.punish(Punishable.PUNISHMENT_THORN);

}

}