Lab 6: Inheritance
due Tuesday, May 26 at 11:59pm on Canvas
Pair Programming Required (or No Credit)
- Both partners fill in, sign, date, and submit the pair programming contract
- Upload the document along with your Lab code to Canvas.
- Only ONE partner submits the Lab code on Canvas.
- BOTH partners submit the contract.
- Please make sure both your names are on all the files.
- If you need help finding a partner, please contact me as soon as possible.
Battle Die Galactica
This lab uses objects to simulate a dice game played between a player and the computer. During this assignment, you will:
- Write a class to hold the data for a die
- Write a class that holds two instances of the die class
- Write a class that represents a player
- Write a subclass that represents an A.I.
- Write a game class
- Optionally, construct a class that uses static methods to test a class
Die Class Specifications
- Create a class named Die to store the data about one die. You must implement the below constructors and methods.
/**
* Die.java
* @author
* @author
* CIS 36B, Lab 6
*/
import java.util.Random;
public class Die {
private int roll;
private int numSides;
/**
* Default constructor for a Die
* Initializes roll to 0
* and numSides to the standard 6
*/
public Die() {
}
/**
* Constructor for a Die
* Initializes roll to 0
* and numSides to specified
* number of sides
* @param numSides the
* number of sides to the die
*/
public Die(int numSides) {
}
/**
* Assigns roll to a random value
* from 1 to numSides
*/
public void makeRoll() {
}
/**
* Returns the roll number
* @return the number generated
* when die is rolled
*/
public int getRoll() {
return -1;
}
}
- Note
1: You are not allowed to implement any additional methods or alter the
class in any other way than to write the given method bodies.
- Note 2: The default number of sides for one die is 6. However, some dice (polyhedral dice) contain a different number of sides.
- For this lab, we will assume that dice can have 6, 8, 10, or 12 sides only.
- Error checking for inappropriately sided dice will happen later in main. You do not need to test for this in the dice class.
- Note 3: to simulate a random roll, you must call methods from the Random class <-- Required or you will receive a 5 pt deduction
- For an appropriate seed, consider the nanoTime() method from the System class
Dice Class Specifications- Create a class named Dice to store two Die Objects.
- For this class, implement the below constructors and methods.
- Note: You are not permitted to add any additional methods or otherwise alter the class except to implement the given methods.
/**
* Dice.java
* @author
* @author
* CIS 36B, Lab6
*/
public class Dice {
private Die die1;
private Die die2;
/**
* Default constructor
* sets both dice to
* be 6 sided
*/
public Dice() {
}
/**
* Constructor to set
* both dice to have the
* same number of sides
* @param sides the number
* of sides of both dice
*/
public Dice(int sides) {
}
/**
* Rolls both dice
*/
public void roll() {
}
/**
* Returns the roll value
* of Die1
* @return the roll value
* of Die1
*/
public int getDie1Roll() {
return -1;
}
/**
* Returns the roll value
* of Die2
* @return the roll value
* of Die2
*/
public int getDie2Roll() {
return -1;
}
/**
* Returns the sum of the
* roll values of Die1
* and Die2
* @return the sum of the rolls
*/
public int getSumRolls() {
return -1;
}
}
Player Class Specifications- Write a class to represent the human player of the game
- The player rolls his or her own pair of dice and has a current score.
- Implement the constructor and other methods as follows.
- Note: You are not permitted to add any additional methods or otherwise alter the class except to implement the given methods.
/**
* Player.java
* @author
* @author
* CIS 36B, Lab 6
*/
public class Player {
private Dice dice;
private int score;
/**
* Player constructor that
* sets the number of sides
* of the dice the player will
* roll and gives the player
* a default score of 0
* @param sides the number of sides
* of the dice
*/
public Player(int sides) {
}
/**
* Returns the player's current score
* @return the current score
*/
public int getScore() {
return -1;
}
/**
* Returns the value of the dice
* @return the dice
*/
public Dice getDice() {
return null;
}
/**
* Updates the score
* @param score the current score
*/
public void setScore(int score) {
}
/**
* Rolls the two player dice
*/
public void rollDice() {
}
/**
* Prints the value of the the rolls
* of the two dice to the console, with
* each roll separated by a blank space
*/
public void printRoll() {
}
/**
* Prints out whether a special roll was made
* and updates the score accordingly
* For snake eyes (two 1s) prints Snake Eyes!
* and updates the score by 5
* When the two die rolls match otherwise,
* prints out Matching! and updates the
* score by 3
* For total of 3, prints out Total of 3!
* and updates the score by 1
* For total of 5, prints out Total of 5!
* and updates the score by 2
* For total of 7, prints out Oh no! Total of 7!
* and resets the score back to 0
* For total of 9, prints out Total of 9!
* and updates the score by 3
* For total of 11, prints out Total of 11!
* and updates the score by 4
* For any other odd number, prints out Odd Roll!
* and updates the score by 2
*/
public void updateScore() {
}
}
AI Class Specifications- Write a class to represent the computer player of the game, which inherits from the Player class
- The AI rolls its own pair of dice and has a current score.
- It also has an additional variable to count how many turns it has taken
- Based
on the number of turns taken, a roll of 7 will affect the score for the
AI differently (please see comment for updateScore method)
- Note that it will override updateScore to handle a roll of 7 differently from the player class
- Implement the constructor and other methods as follows.
- Note: You are not permitted to add any additional methods or otherwise alter the class except to implement the given methods.
/**
* AI.java
* @author
* @author
* CIS 36B, Lab 6
*/
public class AI extends Player {
private static int numTurns;
/**
* Constructor for AI
* Calls Player constructor
* Sets numTurns to 0
* @param sides the number of
* sides of the dice
*/
public AI(int sides) {
}
/**
* Returns the total turns taken by the AI
* @return the number of turns the AI
* has taken
*/
public static int getNumTurns() {
return -1;
}
/**
* Updates the number of turns taken by adding 1
*/
public static void increaseNumTurns() {
}
/**
* Prints out whether a special roll was made
* and updates the score accordingly
* For snake eyes (two 1s) prints Snake Eyes!
* and updates the score by 5
* When the two die rolls match otherwise,
* prints out Matching! and updates the
* score by 3
* For total of 3, prints out Total of 3!
* and updates the score by 1
* For total of 5, prints out Total of 5!
* and updates the score by 2
* For total of 7, and an even number of turns taken
* Prints Total of 7! Double Points for Even Turn * Then, updates AI score by mutliplying by 2 * For total of 7, and an odd number of turns taken
* Prints Total of 7! Zero'd out for Odd Turn
* Then sets AI score to 0
* For total of 9, prints out Total of 9!
* and updates the score by 3
* For total of 11, prints out Total of 11!
* and updates the score by 4
* For any other odd number, prints out Odd Roll!
* and updates the score by 2
*/
@Override public void updateScore() {
}
}
BattleDieGalactica Class Specifications- Write a class to represent one game of Battle Die Galactica
- Implement the below methods, while leaving the constructor to be the default provided by the compiler
- Note: You *are* permitted to add any additional methods in addition to writing the provided methods
- Note that no methods of this class are
static. Therefore you will need to make a BattleDieGalactica object to
use to call your methods.
- Try calling the methods first without this object and notice the error message.
- Then, update your code to call the methods on this object
- This class must work identically to what is shown in the sample output.
- Note that the user should be able to end the game early at any time by typing n in response to the question Roll again? (y/n):
- As
well as the displaying the game play as the game progresses, it must
determine who won (player or computer) or whether the game was a tie,
and print a game ending summary.
- Your program must display this information as shown in the sample output below.
/**
* BattleDieGalactica.java
* @author
* @author
* CIS 36B, Lab 6
*/
import java.util.Scanner;
public class BattleDieGalactica {
private Player player;
private AI ai;
/**
* Prompts the user to input a number of die sides
* Prints out the user choice and
* Constructs a new player and ai based on the number
* of sides of the dice
* Note that the user input will be rounded up to 6, 8, 10
* or 12 and also rounded down to 12 if a higher number is
* input.
* @param input the Scanner
*/
private void gameSetUp(Scanner input) {
System.out.print("Enter the number of sides (6, 8, 10 or 12): ");
}
/**
* Prints out the current score for each opponent
* to the console in the form:
* Player: <score>
* Computer: <score>
* Note: no <> should be displayed
*/
public void printScore() {
}
/**
* Determines whether any player has reached
* 21 points or more, thus ending the game
* @return whether the game is over
*/
private boolean gameOver() {
return false;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("***Welcome to Battle Die Galactica!***\n");
input.close();
}
}
Optional Test Class
- There are a lot of components involved in this assignment.
- To
make sure that each piece is working properly, I recommend that you
create an optional GameTest.java class where you call the different
methods you write as you go along to see that they are working properly.
- For example:
/**
* GameTest.java
* @author
* @author
* CIS 36B Lab 6
*/
public class GameTest {
public static void main(String[] args) {
System.out.println("***Testing Die Class***");
Die d = new Die(6);
d.makeRoll();
System.out.println("Die roll: " + d.getRoll());
System.out.println("\n***Testing Dice Class***");
Dice dice = new Dice(8);
dice.roll();
System.out.println("Die 1 roll: " + dice.getDie1Roll());
System.out.println("Die 2 roll: " + dice.getDie2Roll());
System.out.println("\n***Testing Player Class***");
Player player = new Player(6);
player.rollDice();
player.printRoll();
System.out.println("Score: " + player.getScore());
//add more method calls where needed
}
}
Sample Output:
***Welcome to Battle Die Galactica!***
Enter the number of sides (6, 8, 10 or 12): 6
6-sided dice!
Roll the dice? (y/n): n
Game summary:
Player: 0
Computer: 0
It's a tie!
Sample Output:
***Welcome to Battle Die Galactica!***
Enter the number of sides (6, 8, 10 or 12): 7
8-sided dice!
Roll the dice? (y/n): y
Your Roll: 2 5
Oh no! Total of 7!
Current scores:
Player: 0
Computer: 0
Counter Roll: 1 2
Total of 3!
Current scores:
Player: 0
Computer: 1
Roll again? (y/n): y
Your Roll: 3 3
Matching!
Current scores:
Player: 3
Computer: 1
Counter Roll: 1 2
Total of 3!
Current scores:
Player: 3
Computer: 2
Roll again? (y/n): y
Your Roll: 5 7
Current scores:
Player: 3
Computer: 2
Counter Roll: 7 2
Total of 9!
Current scores:
Player: 3
Computer: 5
Roll again? (y/n): y
Your Roll: 5 6
Total of 11!
Current scores:
Player: 7
Computer: 5
Counter Roll: 6 2
Current scores:
Player: 7
Computer: 5
Roll again? (y/n): y
Your Roll: 5 4
Total of 9!
Current scores:
Player: 10
Computer: 5
Counter Roll: 6 6
Matching!
Current scores:
Player: 10
Computer: 8
Roll again? (y/n): n
Game summary:
Player: 10
Computer: 8
Congratulations! You win!
Sample Output: ***Welcome to Battle Die Galactica!***
Enter the number of sides (6, 8, 10 or 12): 7
8-sided dice!
Roll the dice? (y/n): y
Your Roll: 1 5
Current scores:
Player: 0
Computer: 0
Counter Roll: 4 6
Current scores:
Player: 0
Computer: 0
Roll again? (y/n): y
Your Roll: 2 6
Current scores:
Player: 0
Computer: 0
Counter Roll: 1 4
Total of 5!
Current scores:
Player: 0
Computer: 2
Roll again? (y/n): y
Your Roll: 4 6
Current scores:
Player: 0
Computer: 2
Counter Roll: 2 3
Total of 5!
Current scores:
Player: 0
Computer: 4
Roll again? (y/n): y
Your Roll: 7 1
Current scores:
Player: 0
Computer: 4
Counter Roll: 8 5
Odd Roll!
Current scores:
Player: 0
Computer: 6
Roll again? (y/n): y
Your Roll: 5 6
Total of 11!
Current scores:
Player: 4
Computer: 6
Counter Roll: 3 3
Matching!
Current scores:
Player: 4
Computer: 9
Roll again? (y/n): y
Your Roll: 2 1
Total of 3!
Current scores:
Player: 5
Computer: 9
Counter Roll: 4 2
Current scores:
Player: 5
Computer: 9
Roll again? (y/n): y
Your Roll: 1 5
Current scores:
Player: 5
Computer: 9
Counter Roll: 6 1
Total of 7! Zero'd Out for Odd Turn!
Current scores:
Player: 5
Computer: 0
Roll again? (y/n): y
Your Roll: 7 6
Odd Roll!
Current scores:
Player: 7
Computer: 0
Counter Roll: 8 2
Current scores:
Player: 7
Computer: 0
Roll again? (y/n): y
Your Roll: 7 4
Total of 11!
Current scores:
Player: 11
Computer: 0
Counter Roll: 2 7
Total of 9!
Current scores:
Player: 11
Computer: 3
Roll again? (y/n): y
Your Roll: 3 1
Current scores:
Player: 11
Computer: 3
Counter Roll: 8 8
Matching!
Current scores:
Player: 11
Computer: 6
Roll again? (y/n): y
Your Roll: 8 3
Total of 11!
Current scores:
Player: 15
Computer: 6
Counter Roll: 4 1
Total of 5!
Current scores:
Player: 15
Computer: 8
Roll again? (y/n): y
Your Roll: 6 1
Oh no! Total of 7!
Current scores:
Player: 0
Computer: 8
Counter Roll: 6 7
Odd Roll!
Current scores:
Player: 0
Computer: 10
Roll again? (y/n): y
Your Roll: 4 6
Current scores:
Player: 0
Computer: 10
Counter Roll: 2 4
Current scores:
Player: 0
Computer: 10
Roll again? (y/n): y
Your Roll: 1 5
Current scores:
Player: 0
Computer: 10
Counter Roll: 2 1
Total of 3!
Current scores:
Player: 0
Computer: 13
Roll again? (y/n): y
Your Roll: 5 2
Oh no! Total of 7!
Current scores:
Player: 0
Computer: 13
Counter Roll: 1 1
Snake Eyes!
Current scores:
Player: 0
Computer: 18
Roll again? (y/n): y
Your Roll: 3 6
Total of 9!
Current scores:
Player: 3
Computer: 18
Counter Roll: 6 8
Current scores:
Player: 3
Computer: 18
Roll again? (y/n): y
Your Roll: 2 7
Total of 9!
Current scores:
Player: 6
Computer: 18
Counter Roll: 8 2
Current scores:
Player: 6
Computer: 18
Roll again? (y/n): y
Your Roll: 1 2
Total of 3!
Current scores:
Player: 7
Computer: 18
Counter Roll: 4 3
Total of 7! Double Points for Even Turn!
Game summary:
Player: 7
Computer: 36
Computer wins! Better luck next time.
What to Submit:- Submit your completed Die.java, Dice.java, Player.java, AI.java, BattleDieGalactica.java file (make sure both your names are on all files) to Canvas.
- One partner submits all of the source code files. Both partners submit the pair programming contract.
- 5 point deduction for missing contract
- 5
point deduction for any additional package statements (alteration to
starter code) - please remove added package statements before submitting
your assignment
- 5 point deduction for not using the Random class to implement randomization for this assignment
- 5 point deduction if your code is not properly formatted.
- Go to Source ->Format in Eclipse to autoformat your code
- 5 point deduction if your names are not on all of the files.
How You Will Be Graded:- 100 points: The assignment works as shown in the sample output. All required features are implemented and implemented correctly.
- 80-100
points: The assignment works mostly as shown in the sample output. Most
required features are implemented and implemented correctly.
- 40-80
points: Some of the assignment works as shown in the sample output. Some
required features are implemented and implemented correctly.
- 10-40
points: Serious problems in implementation and little correspondence
between sample output and what is shown. Few of the features implemented
or implemented correctly.
- 0 points: Code does not compile or outputs an error at runtime.
|
