### Solution for Programming Exercise 6.1

THIS PAGE DISCUSSES ONE POSSIBLE SOLUTION to the following exercise from this on-line Java textbook.

Exercise 6.1: Write an applet that shows a pair of dice. When the user clicks on the applet, the dice should be rolled (that is, the dice should be assigned newly computed random values). Each die should be drawn as a square showing from 1 to 6 dots. Since you have to draw two dice, its a good idea to write a subroutine, "void drawDie(Graphics g, int val, int x, int y)", to draw a die at the specified (x,y) coordinates. The second parameter, val, specifies the value that is showing on the die. Assume that the size of the applet is 100 by 100 pixels. Here is a working version of the applet. (My applet plays a clicking sound when the dice are rolled. See the solution to see how this is done.)

Discussion

We need a subclass of JApplet to make the applet. That class will contain a nested class, declared as a subclass of JPanel, to make the drawing surface on which the dice will actually be drawn. We will need an object to respond to mouse events. That could be either the applet object or the drawing surface object (or even another object created just for the purpose.) I will use the applet as a MouseListener.

The drawing class in the applet is named DiceCanvas. Whenever two classes are involved in solving one problem, there is some question of how to divide up responsibilities between the two classes. In this case, I decided to make the canvas responsible only for drawing. The DiceCanvas class defines only one method, paintComponent(). All the other programming (that is, rolling the dice and interacting with the user) is in the main applet class.

The applet must be declared to "implement MouseListener", and it must define the mousePressed() method to roll the dice. (The other methods of the MouseListener interface will be empty.) The applet's init() method creates an object named dice of type DiceCanvas. This object is set to be the "content pane" of the applet with the command

```            setContentPane(dice);
```

It would have been OK to add it to the applet's existing content pane instead, but since the applet will contain only one component, it makes sense to completely replace the content pane with that component. The applet is supposed listen for mouse events from this component, so the applet is registered with dice using the command

```            dice.addMouseListener(this);
```

where "this" is, of course, a name for the applet object itself.

Looking at the rest of the applet class, I defined the mousePressed() routine simply as

```            public void mousePressed(MouseEvent evt) {
roll();
}
```

and I defined the roll() subroutine to roll the dice. It would be reasonable to put the code for rolling the dice in the mousePressed() routine, but writing a subroutine to do it makes the program a little easier to modify for the next two exercises. Anyway, when you can identify a self-contained, meaningful task to be performed, it's never a bad a idea to write a subroutine to do it. It will make the program more readable, if nothing else. My roll subroutine assigns random values to the dice and calls dice.repaint() so that the new values will be shown. It also plays the clicking sound with the command

```            play(getCodeBase(), "click.au");
```

The play() method is a predefined instance method in the JApplet class. The sound comes from a file. The second parameter, "click.au", is the name of the file that contains the sound. The first parameter, getCodeBase(), specifies the directory that contains the sound file. This parameter is actually a URL, but all you need to know is that getCodeBase() specifies that the sound file is in the same directory that contains the compiled class file of the applet. Unfortunately, not all sound files can be played by Java, and some sound files might work on one platform but not on another. A sound file with a name ending in ".au" is most likely to work. An interesting thing about the play() method is that it only starts the sound playing. It doesn't wait for the playback to finish. So, the applet continues to run while the sound plays. Here is a link that you can use to download the click sound: click.au.

The hardest part of this exercise is drawing the dice. I made each die 35 pixels wide, leaving a 10 pixel border on each side and 10 pixels between the dice. The top left corner of the left die is at (10,10), the top left corner of the right die is at (55,55). The 55 includes the 10 pixel border on the left, the 35 pixel width of the other die, and the 10 pixels between the dice. The paint method calls a drawDie() routine to draw each die, using the commands:

```                drawDie(g, die1, 10, 10);
drawDie(g, die2, 55, 55);
```

where die1 is the numerical value shown on the first die and die2 is the numerical value of the second die.

As for the drawDie routine, there are two quite different algorithms that could have been used for drawing the dots. Either:

```              if the value shown is 1
draw 1 dot (in the center)
else if the value shown is 2
draw 2 dots (in the top-left and bottom-right corners)
.
.
.
else if the value shown is 6
draw 6 dots (along the left and right edges)
```

Or:

```              if the value has a dot in the top-left corner
draw the top-left dot
else if the value has a dot in the top-right corner
draw the top-right dot
.
.
.
else if the value has a dot in the bottom-right corner
draw the bottom-right dot
```

Although the first algorithm is more obvious, the second requires much less typing. (The first algorithm ends up using 21 drawOval() commands, while the second uses only 7.) Furthermore, after drawing the dice on paper, I found that the conditions for testing when a given dot needs to be drawn are simpler than I expected. For example, the values that need a dot in the top-left position are all the values greater than 1. The algorithm leads to my drawDice() routine:

```      void drawDie(Graphics g, int val, int x, int y) {
// Draw a die with upper left corner at (x,y).  The die is
// 35 by 35 pixels in size.  The val parameter gives the
// value showing on the die (that is, the number of dots).
g.setColor(Color.white);
g.fillRect(x, y, 35, 35);
g.setColor(Color.black);
g.drawRect(x, y, 34, 34);
if (val > 1)  // upper left dot
g.fillOval(x+3, y+3, 9, 9);
if (val > 3)  // upper right dot
g.fillOval(x+23, y+3, 9, 9);
if (val == 6) // middle left dot
g.fillOval(x+3, y+13, 9, 9);
if (val % 2 == 1) // middle dot (for odd-numbered val's)
g.fillOval(x+13, y+13, 9, 9);
if (val == 6) // middle right dot
g.fillOval(x+23, y+13, 9, 9);
if (val > 3)  // bottom left dot
g.fillOval(x+3, y+23, 9, 9);
if (val > 1)  // bottom right dot
g.fillOval(x+23, y+23, 9,9);
}
```

It took some care to figure out the numbers to use in the fillOval commands. The individual dots have a diameter of 9 pixels. There are three rows of dots, which have a combined height of 27 pixels. That leaves 35-27, or 8 pixels for spacing. I use 3 pixels between the dots and the edge of the die, and 1 pixel between rows. This puts the tops of the rows at 3, 3+9+1, and 3+9+1+9+1, that is, at 3, 13, and 23. The columns use the same numbers. (If you believe that I got all this right the first time, I won't disillusion you!)

The nested DiceCanvas class is fairly simple. It's paintComponent method just draws the two dice and the border around the applet:

```     class DiceCanvas extends JPanel {
// A nested class to represent the drawing surface
// on which the dice are displayed.
public void paintComponent(Graphics g) {
// The paint method draws a blue border and then
// draws the two dice.
super.paintComponent(g);  // fill with background color.
g.setColor( Color.blue );
g.drawRect(0,0,99,99);
g.drawRect(1,1,97,97);
drawDie(g, die1, 10, 10);
drawDie(g, die2, 55, 55);
}
}
```

Note that this nested class calls the drawDie routine which is an instance method in the main applet class. Non-static nested classes always have access to the instance variables and instance methods of the class in which they are nested.

There are, of course, many different basic designs for this applet. We could move most of the programming into the DiceCanvas class, leaving the main class with nothing more than an init() method. We could use an anonymous class for the canvas or for the mouse listener or both. Instead of using the Math.random() function, we could use the Random class that was introduced in Section 5.3. I have provided an alternative solution that implements some of these ideas. In this alternative version, two anonymous classes are created in the init() method. You'll find the alternative solution below, after my original solution.

The Solution

```
/*
Shows a pair of dice that are rolled when the user clicks on the
applet.  It is assumed that the applet is 100-by-100 pixels.  A clicking
sound is played when the dice are rolled.
*/

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ClickableDice extends JApplet implements MouseListener {

int die1 = 4;  // The values shown on the dice.
int die2 = 3;

DiceCanvas dice;  // An object belonging to the nested class
// DiceCanvas, which is used as the drawing
// surface on which the dice are displayed.

public void init() {
// To initialize the applet, create the drawing surface
// object and use it as the applet's content pane.
// Set the applet to listen for events from the DiceCanvas,
// and set the background color of the DiceCanvas.
dice = new DiceCanvas();
setContentPane(dice);
dice.setBackground( new Color(200,200,255) );  // light blue
}

void drawDie(Graphics g, int val, int x, int y) {
// Draw a die with upper left corner at (x,y).  The die is
// 35 by 35 pixels in size.  The val parameter gives the
// value showing on the die (that is, the number of dots).
g.setColor(Color.white);
g.fillRect(x, y, 35, 35);
g.setColor(Color.black);
g.drawRect(x, y, 34, 34);
if (val > 1)  // upper left dot
g.fillOval(x+3, y+3, 9, 9);
if (val > 3)  // upper right dot
g.fillOval(x+23, y+3, 9, 9);
if (val == 6) // middle left dot
g.fillOval(x+3, y+13, 9, 9);
if (val % 2 == 1) // middle dot (for odd-numbered val's)
g.fillOval(x+13, y+13, 9, 9);
if (val == 6) // middle right dot
g.fillOval(x+23, y+13, 9, 9);
if (val > 3)  // bottom left dot
g.fillOval(x+3, y+23, 9, 9);
if (val > 1)  // bottom right dot
g.fillOval(x+23, y+23, 9,9);
}

void roll() {
// Roll the dice by randomizing their values.  Tell the
// system to repaint the applet, to show the new values.
// Also, play a clicking sound to give the user more feedback.
die1 = (int)(Math.random()*6) + 1;
die2 = (int)(Math.random()*6) + 1;
play(getCodeBase(), "click.au");
dice.repaint();
}

public void mousePressed(MouseEvent evt) {
// When the user clicks the applet, roll the dice.
roll();
}

public void mouseReleased(MouseEvent evt) { }  // Required for the
public void mouseClicked(MouseEvent evt) { }   //    MouseListener
public void mouseEntered(MouseEvent evt) { }   //       interface.
public void mouseExited(MouseEvent evt) { }

class DiceCanvas extends JPanel {
// A nested class to represent the drawing surface
// on which the dice are displayed.
public void paintComponent(Graphics g) {
// The paint method draws a blue border and then
// draws the two dice.
super.paintComponent(g);  // fill with background color.
g.setColor( Color.blue );
g.drawRect(0,0,99,99);
g.drawRect(1,1,97,97);
drawDie(g, die1, 10, 10);
drawDie(g, die2, 55, 55);
}
}

} // end class ClickableDice

```

### An Alternative Solution

```    /* An alternative version of the Clickable Dice applet
that uses two anonymous classes and an object of
type java.util.Random.
*/

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ClickableDiceAlternative extends JApplet {

static Random rand = new Random();  // A source of random numbers.

int die1 = 4;  // The values shown on the dice.
int die2 = 3;

JPanel dice;   // The drawing surface on which the dice are drawn.

public void init() {
// To initialize the applet, create the drawing surface
// object and use it as the applet's content pane.
// Set the applet to listen for events from the DiceCanvas,
// and set the background color of the DiceCanvas.
dice = new JPanel() {
// A JPanel to act as the drawing surface on which
// the dice are displayed.
public void paintComponent(Graphics g) {
super.paintComponent(g);  // fill with background color.
g.setColor( Color.blue );
g.drawRect(0,0,99,99);
g.drawRect(1,1,97,97);
drawDie(g, die1, 10, 10);
drawDie(g, die2, 55, 55);
}
};
setContentPane(dice);
dice.setBackground( new Color(200,200,255) );  // light blue
// A mouse listener that will roll the dice
// when the user clicks the dice canvas.
public void mousePressed(MouseEvent evt) {
roll();
}
});
}

void drawDie(Graphics g, int val, int x, int y) {
// Draw a die with upper left corner at (x,y).  The die is
// 35 by 35 pixels in size.  The val parameter gives the
// value showing on the die (that is, the number of dots).
g.setColor(Color.white);
g.fillRect(x, y, 35, 35);
g.setColor(Color.black);
g.drawRect(x, y, 34, 34);
if (val > 1)  // upper left dot
g.fillOval(x+3, y+3, 9, 9);
if (val > 3)  // upper right dot
g.fillOval(x+23, y+3, 9, 9);
if (val == 6) // middle left dot
g.fillOval(x+3, y+13, 9, 9);
if (val % 2 == 1) // middle dot (for odd-numbered val's)
g.fillOval(x+13, y+13, 9, 9);
if (val == 6) // middle right dot
g.fillOval(x+23, y+13, 9, 9);
if (val > 3)  // bottom left dot
g.fillOval(x+3, y+23, 9, 9);
if (val > 1)  // bottom right dot
g.fillOval(x+23, y+23, 9,9);
}

void roll() {
// Roll the dice by randomizing their values.  Tell the
// system to repaint the applet, to show the new values.
// Also, play a clicking sound to give the user more feedback.
die1 = rand.nextInt(6) + 1;
die2 = rand.nextInt(6) + 1;
play(getCodeBase(), "click.au");
dice.repaint();
}

} // end class ClickableDiceAlternative
```

[ Exercises | Chapter Index | Main Index ]