Question

You will write a two-class Java program that implements the Game of 21. This is a fairly simple game where a player plays against a “dealer”. The player will receive two and optionally three numbers. Each number is randomly generated in the range 1 to 11 inclusive (in notation: [1,11]). The player’s score is the sum of these numbers. The dealer will receive two random numbers, also in [1,11]. The player wins if its score is greater than the dealer’s score and is also less than or equal to 21. A tie goes to the dealer.
The player may wager an amount of money before receiving each number. If the player wins, the wager is added to the player’s total money. If the player loses, the wager is subtracted from the player’s total money.
The game is played as follows:
The player starts with a total amount of money, 100.00 in this case.  
The dealer asks for an initial bet from the player. This is called an “ante”. The amount of money the player can bet has to be less than or equal to the player’s total amount of money.
Then, the dealer generates a random number for the player. That is added to the player’s score, which is initially zero. The dealer then generates a random number for itself and adds that to the dealer’s score.
The player may place a bet with the same betting conditions as mentioned above.
Then, the dealer generates another number for the player and for itself.
Another bet may be placed by the player.
The dealer then asks if the player wants one more number. If yes, the dealer generates another random number for the player.  
Finally, the dealer checks if the player has won. If so, the player’s total money is the sum of the player’s initial money and the total bets the player has made. If the player has lost, the player’s total money is the initial money minus the total amount the player has bet.
The Program Structure.
The program consists of two Java class definitions: Dealer21 and Driver21. The specification for these class definitions is as follows.
Dealer21.java
This class simulates the dealer. The dealer manages the state of the game, including the player’s money, bets, and the score for both player and dealer, and generates random numbers. The dealer also determines the winner of the game.
Member variable declarations (name, data type, purpose):
dealerScore, integer, the sum of the numbers generated for the dealer.
playerScore, integer, the sum of the numbers generated for the player.  
playerBet, double, the sum of the bets placed by the player.
playerMoney, double, the player’s initial amount of money.
rand, Random, generates random numbers for the game.
Methods
Constructors: There are two constructors. One takes no parameters, and one takes a single parameter- an integer (could also be a long integer), which will serve as the seed for the instance of Random. Both constructors call the init method (see below), which initializes the first four member variables listed above. In addition to calling init, the first constructor creates an instance of Random using its no-parameter constructor, while the second constructor passes the seed value to the Random constructor (refer to the java.util.Random class in the Java API if necessary).
Private methods:
init: no parameters, no return value. Initializes dealer and player scores to 0, the player bet to 0.0, and the player money to 100.00.
generateNum: no parameters, returns an integer, which is a (uniform) random number in the range 1 to 11, inclusive.
Public methods:
getPlayerBet: no parameters, returns a double, the player’s aggregate bet.

getPlayerMoney: no parameters, returns a double, the player’s money.
getPlayerScore: no parameters, returns an integer, the player’s aggregate score.
getDealerScore: no parameters, returns an integer, the dealer’s aggregate score.
playerWins: no parameters, returns Boolean: true if the player wins, false otherwise.
The player wins if the dealer's score is not 21 and the player's score is less than or equal to 21 and the player's score is greater than the dealer's score.
placeBet: takes a double parameter- the amount of the player’s bet, returns boolean.
Checks if the amount the player has bet so far plus the bet passed in is less than or equal to the player's total money. If this is true, it adds the amount passed in to the player's current bet and returns true, otherwise, the bet passed in is not added and false is returned.
generatePlayerNumber: no parameters, returns an integer, a number in [1,11].
Calls generateNum, adds this number to the player's score, and returns the number generated.
generateDealerNumber no parameters, returns an integer, a number in [1,11].
Calls generateNum, adds this number to the dealer's score, and returns the number generated.

Driver21.java
This class handles console interactions with the player (user). It creates an instance of Dealer21 and uses its public methods (API) to play the game.  
Member variables: none.
Methods: main.
An instance of Dealer21 is created in main. Its methods are called to play the game. Actually, you will write two statements to create the Dealer21 instance: one will call the no-parameter constructor, and one will call the constructor that takes a seed value as a parameter. Comment out the first statement. Use the seed version during development and testing. The seed you use will determine the numbers generated during the game.
The rest of the code in the main method must produce the same output as in the following examples. Use the strings in the example in your code. Use a single java.util.Scanner instance to take the user’s input. Use the nextInt and next Scanner class methods.
Example 1:

You must reproduce this output exactly. Of course, the numbers will change for each run. None of the numbers that appear in the example above should be “hard-coded” in the Driver21 code. For example, this is a statement where the number 100 is hard-coded:
System.out.println("You have 100.00 money to bet with.");
This number should be obtained from the Dealer object. This is the correct way to write the statement:
System.out.println("You have "+dealer.getPlayerMoney()+" money to bet with.");
All numbers seen in the output above should be obtained from the Dealer object.

Another example follows, where the player does not want a third number (answers “N”):

Notice that the same “random” numbers were generated in both examples. This is because the same seed, 1234567, was used. You may use any integer for a seed number.
What happens if a player bet is higher than the player’s resources? The player bet is a running sum of all bets the player has made. The next bet a player makes has to be less than or equal to the difference of the player bet and the player total money. If the bet is too high, the placeBet method returns false. The bet will not be accepted. Since we are not using loops in this project, the game moves on.  

The following example shows what the program does in the case of a bet that was too high.

There are many refinements that could be made to this program. As with all software, new ideas come to mind once you observe the program in action. This is why good coding practices are so important: software is malleable and is constantly changing. Good design and good coding make modification much easier to achieve.

Answer 1

**************************************************Code **************************************

import java.util.*;

class Dealer21 {
    // Instance variables
    private int dealerScore = 0;
    private int playerScore = 0;
    private double playerBet = 0;
    private double playerMoney = 0;
    private Random rand;

    private void init() {
        // This function is used to initialize the all the instance variables
        playerScore = 0;
        dealerScore = 0;
        playerBet = 0;
        playerMoney = 100.0;
    }

    public Dealer21() {
        // No parameter constructor creating the random object and calling init function
        rand = new Random();
        init();
    }

    public Dealer21(int seed) {
        // Constructor with one parameter and creating the random object with seed and calling init method
        rand = new Random(seed);
        init();
    }

    public void addMoneyToPlayer(double money) {
        // Used to add/subtract the money to player money
        playerMoney += money;
    }

    private int generateNum() {
        // This function is used to generate a number between 1 and 11
        return rand.nextInt(11) + 1;
    }

    public double getPlayerBet() {
        // Used to return the player bet
        return playerBet;
    }

    public double getPlayerMoney() {
        // Used to return the player money
        return playerMoney;
    }

    public double getPlayerScore() {
        // Used to return the player score
        return playerScore;
    }

    public double getDealerScore() {
        // Used to return the dealer score
        return dealerScore;
    }

    public boolean playerWins() {
        // This function checks whether player wins or not by checking the given condition returns true if wins
        if (dealerScore != 21 && playerScore < 21 && playerScore > dealerScore) {
            return true;
        }
        return false;
    }

    public boolean placeBet(double bet) {
        // Checks for whether bet can be placed or not if yes then add to the bet and returns true else returns false
        if ((playerBet + bet) <= playerMoney) {
            playerBet += bet;
            return true;
        }
        return false;
    }

    public int generatePlayerNumber() {
        // This is public function generating the number for player and returns that number
        int num = generateNum();
        System.out.println("PlayerNumber:" + num);
        playerScore += num;
        return num;
    }

    public int generateDealerNumber() {
        // This is the public function for generating the number for dealer and returns it
        int num = generateNum();
        System.out.println("DealerNumber:" + num);
        dealerScore += num;
        return num;
    }

}

public class Driver21 {
    // This is the Driver class
    public static void main(String args[]) {
        double bet;
        // Main method from here we will call the all the functions and takes the input from user
        // And decides the who is the winner
        boolean status;
        String option;
        Scanner in = new Scanner(System.in);
        // Creating object for the Scanner class for taking the data from the user
        //Dealer21 obj = new Dealer21();
        int seed = (int) Math.random() * 1000;
        Dealer21 obj = new Dealer21(seed);
        // Creating the object for dealer class to deal with it
        System.out.println("Player Money:" + obj.getPlayerMoney());
        // Printing initial player money
        for (int i = 0; i < 2; i++) {
            System.out.println("Enter the bet:");
            // Asking the user to enter the bet
            bet = in.nextDouble();
            status = obj.placeBet(bet);
            if (status) {
                // Here we will generate the random numbers for the player and dealer
                obj.generatePlayerNumber();
                obj.generateDealerNumber();
            } else {
                // Displaying the message if bet can't be placed
                System.out.println("You have " + obj.getPlayerMoney() + " money to bet with.");
            }
        }
        System.out.println("Wants one more number:");
        // Asking the user to want another number if yes generate one more number for player
        option = in.next().toLowerCase();
        if (option == "y") {
            obj.generateDealerNumber();
        }
        status = obj.playerWins();
        // Checking who is winning and displaying the scores of player and dealer
        System.out.println("PlayerScore:" + obj.getPlayerScore() + "->DealerScore:" + obj.getDealerScore());
        if (status) {
            System.out.println("Player Wins");
            obj.addMoneyToPlayer(obj.getPlayerBet());
        } else {
            System.out.println("Dealer wins");
            obj.addMoneyToPlayer(-obj.getPlayerBet());
        }
        System.out.println("Player Money:" + obj.getPlayerMoney());
        // Final player money

    }
}

*****************************Code Screens*****************************************

1 import java.util.*; class Dealer21 { 3 4 Instance variables private int dealerScore 0; private int playerScore0; private double playerBet 0 private double playerMoney0; private Random rand; System Monitor 12 13 14 15 16 vate void init) f This function is used to initialize the all the instance variables playerScore0 dealerscore-6; playerBet 0; playerMoney100.0; 18 19 20 21 public Dealer21() No parameter constructor creating the random object and calling init function rand new Random); init) 23 24 25 26 27 28 29 30 31 32 public Dealer21 (int seed) Constructor with one parameter and creating the random object with seed and calling init method rand new Random (seed); init) public void addMoneyToPlayer(double money) [ Used to add/subtract the money to player money playerMoney-money; 34 35 36 37 38 39 40 private int generateNum() [ This function is used to generate a number between 1 and 11 return rand.nextInt(n: 11) + 1;

public double getPlayerBet() 41 42 43 /Used to return the player bet return playerBet; 45 public double getPlayerMoney) 47 48 49 50 51 52 53 54 Used to return the player money return playerMoney public double getPlayerScore() ( /Used to return the player score return playerScore; public double getDealerScore) //Used to return the dealer score return dealerScore; 57 59 61 public boolean playerWins() This function checks whether player wins or not by checking the given condition returns true if wins if (dealerScore!-21 && playerScore < 21 && playerScore dealerScore) 63 64 65 return true return false; 67 68 69 70 71 72 73 74 75 76 public boolean placeBet (double bet) Checks for whether bet can be placed or not if yes then add to the bet and returns true else returns false if ((playerBet bet) < playerMoney) playerBet +bet; return true; return false public int generatePlayerNumber() 78 79 80 This is public function generating the number for player and returns that number int num-generateNum();

System.out.printin("PlayerNumber:" num) playerScorenum; return num; 82 83 84 85 86 87 public int generateDealerNumber) This is the public function for generating the number for dealer and returns it int num-generateNum(); System. out.println ("DealerNumber:" num); dealerScorenum; return num 89 90 91 92 93 94 95 96 97 98 public class Drive r21 { //This is the Driver class public static void main(String args[]) double bet; Main method from here we will call the all the functions and takes the input from user 100 101 102 103 104 105 106 107 108 109 110 And decides the who is the winner boolean status; String option; Scanner în = new Scanner(System.in); Creating object for the Scanner class for taking the data from the user /Dealer21 obj -new Dealer21 O int seed -(int) Math.random() 1000; Dealer21 obj-new Dealer21(seed); Creating the object for dealer class to deal with it System.out.println("Player Money:"+ obj.getPlayerMoney (O); Printing initial player money 112 113 114 115 116 System. out.println ("Enter the bet:"); 7Asking the user to enter the bet bet = in.nextDouble(); statusobj.placeBet (bet); if (status) 118 119 120 Here we will generate the random numbers for the player and dealer obj.generatePlayerNumber) obj.generateDealerNumber)

121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 else 7Displaying the message if bet can't be placed System.out.println("You have "obj.getPlayerMoney () "money to bet with."); System.out.println("Wants one more number:") //Asking the user to want another number if yes generate one more number for player option in.next().toLowerCase(): if (option"y") i obj.generateDealerNumber); status obj.playerWins (): Checking who is winning and displaying the scores of player and dealer System. out.println("PlayerScore:"+ obj.getPlayerScore() + "->DealerScore:"obj.getDealerScore()); if (status) System.out.println ("Player Wins") obj.addMoneyToPlayer (obj.getPlayerBet()): else System.out.println ("Dealer wins") obj.addMoneyToPlayer(-obj.getPlayerBet ()); System. out.println("Player Money:"obj.getPlayerMoney ()); 7Final player money

*****************************Output Screens*****************************************

javasys1091@sys1091:-/IdeaProjects/ds/src$ javac Driver21.java sys1091@sys1091:~/IdeaProjects/ds/src$ java Driver21 Player Money:10Θ.Θ Enter the bet: PlayerNumber 1 DealerNumber:7 Enter the bet: PlayerNumber:9 DealerNumber:6 Wants one more number: PlayerScore 10.0->DealerScore 13.0 Dealer wins Player Money: 70.0 sys1091@sys1091:~/IdeaProjects/ds/src$ java Driver21 Player Money 100.0 Enter the bet: 150 You have 100.Θ money to bet with. Enter the bet: 100 PlayerNumber:1 DealerNumber:7 Wants one more number: PlayerScore:1.0->DealerScore:7.0 Dealer wins Player Money:0.0 sys1091@sys1091: /IdeaProjects/ds/src$ java Driver21 Player Money 100.0 Enter the bet: 10 PlayerNumber 1 DealerNumber:7 Enter the bet: 20 PlayerNumber:9 DealerNumber:6 Wants one more number: PlayerScore: 10.0-»Dealerscore : 13 . Θ Dealer wins Player Money: 70.0 sys1091@sys1091:-/IdeaProjects/ds/src$

sys1091@sys1091: /IdeaProjects/ds/src$ javac Driver21.java sys1091@sys1091: /IdeaProjects/ds/src$ java Driver21 Player Money 100.0 Enter the bet: 10 PlayerNumber:6 DealerNumber:4 Enter the bet: 20 PlayerNumber:11 DealerNumber:3 Wants one more number: PlayerScore: 17.0->DealerScore:7.0 Player Wins Player Money 130.0 sys1091@sys1091:~/IdeaProjects/ds/src$ java Driver21 Player Money 100.0 Enter the bet: 200 You have 100.0 money to bet with. Enter the bet: 10 PlayerNumber:6 DealerNumber:4 Wants one more number: PlayerScore:6.0->DealerScore:4.0 Player Wins Player Money 110.0 sys1091@sys1091:~/IdeaProjects/ds/src$ java Driver21 Player Money 100.0 Enter the bet: 30 PlayerNumber:6 DealerNumber:4 Enter the bet: 40 PlayerNumber:11 DealerNumber:3 Wants one more number: PlayerScore: 17.0->DealerScore:7.0 Player Wins Player Money 170.0 sys1091@sys1091:-/IdeaProjects/ds/src$