A test program is a laboratory that you complete on your own, without the help of others. It is a form of take-home exam. You may consult your text, your notes, your lab work, or our on-line examples and web pages, but use of any other source for code is forbidden. You may not discuss these problems with anyone aside from the course instructor. You may only ask the TA's for help with hardware problems or difficulties in retrieving your program from a disk or network.

Introduction

The game Brickout (originally known as breakout) was an early video game conceived in the mid-70's at Atari as a follow-up to Pong. The history, which is described at the website http://classicgaming.gamespy.com/View.php?view=Articles.Detail&id=395, involves the young Steve Jobs and Steve Wozniak, who later were the cofounders of Apple.

The idea of the game is to use a ball and paddle to knock out bricks in a wall. Rather than explain it, you will find it easier to check out the demo below.

If you want to experience something a bit more elaborate, you can download a working Mac version version on-line.

Our simplified game begins with a set of 10 rows of 10 bricks each at the top of the board, and with a paddle at the bottom. When the user clicks on the screen the first ball appears in the center of the screen, just under the bottom-most row of bricks. It starts by moving generally downward (usually at an angle) and then bounces off the paddle, the side walls and top of the court, and the bricks remaining on the screen. Each time a brick is hit by the ball, the ball bounces off, but the brick is destroyed.

If a ball goes off the bottom of the screen then it is lost. The player can use up to three balls while playing a game. If the player destroys all of the bricks before the third ball is lost, then they win. Otherwise they lose. When the game is over, the user can click again on the screen to start a new game. This results in drawing a new set of bricks and a moving ball.

There can only be one ball in play at a time. Thus if the player clicks when a ball is still in play, the click should be ignored.

An interesting effect occurs when all of the bricks in a column have been destroyed and the ball slips through. At that time the ball will bounce around in the portion of the window, destroying bricks, until it falls through another hole and returns to the lower portion of the court. Interestingly, this effect should occur naturally with no extra effort on your part. Your program merely keeps the ball bouncing around, no matter where it happens to be on the court.

Game Details

You should begin the game by drawing the playing field, the paddle, and the bricks on the canvas. The top two rows of bricks are red, the next two are orange, then yellow, green, and finally cyan. The constants in the starter project work with a window that is 400 pixels wide and 500 pixels tall.

The x-speed should be determined by a random double generator. We have found that a motion in the y-direction of 0.2 pixels per millisecond and a motion in the x-direction of 0.1 to 0.4 per millisecond results in a very playable game. Please make sure that the ball travels at a constant speed per millisecond in this game (like the vehicles in Frogger), even if the pauses take longer than expected.

Program Design

Your program should consist of four classes:

BrickOut:

The class that is responsible for all user interaction, it is responsible for drawing the initial configuration on the canvas and responding to mouse clicks and moves, and displaying the state of the game.

MovingBall:

The class that generates the animated ball that bounces around the court. It is responsible for moving the ball around the court, bouncing off of the court walls, bricks, and the paddle.

BrickSet:

The class responsible for drawing and managing the bricks. It contains an instance variable representing the two-dimensional array of bricks. It has a method

	public boolean bounce(FilledRect ball)
    

that determines whether the ball overlaps a ball, returning a boolean and removing any bricks that it overlaps. We have provided a private method getElementAt(x,y). If a brick is at location (x,y), then getElementAt(x,y) will return the Slot (see below) corresponding to the array entry of that brick. If there is no brick in that location then the method returns null.

Slot:

This class is provided for you. The constructor creates an object representing a pair of a row and column. It has methods getRow() and getCol().

As indicated in the heading of this document, you will need to turn in a design plan for your BrickOut program well before the program itself. This design should be a clear and concise description of your planned organization of the program. Note that this design counts for 20% of your grade on the project, so please take this requirement seriously.

Include in your design a sketch of each class (excluding the Slot class) including the types and names of all instance variables and constants you plan to use, and the headers of all methods you expect to write. You should write a brief description of the purpose/function of each instance variable and method. These should be sufficient to form the comments on each of these in your final program.

In addition, you should provide pseudo-code for any method whose implementation is at all complicated. In particular, if a method is complicated enough that it will invoke other methods you write (rather than just invoking methods provided by Java or our library), or involves a loop, then include pseudo-code for the method so that we will see how you expect to use your own methods.

Implementation Order

Begin by downloading the starter project from the handouts web page. We strongly encourage you to proceed as suggested below to ensure that you can turn in a running program. While a partial program will not receive full credit, a program that does not run at all generally receives a lower grade. Moreover it is easier to debug a program if you know that some parts do run correctly.

• Look over the Pong game example from earlier in the semester. You will find a full version in the notes for lecture 9. You will copy much of this code in getting started.
• Experiment with the demonstration program to make sure you understand what is required.
• Write a program that draws the court and the bricks across the top. The constructor of BrickSet should do the actual drawing of the bricks and maintain the array of bricks.
• Add code to create the paddle and to make it move back and forth following the mouse, yet stay within the court boundaries. Recall that only the x coordinate of the paddle changes.
• Write the class MovingBall. A moving ball should be created when the user clicks on the window, providing that another ball does not already exist. Provide functionality so that the ball bounces off the sides of the court and the paddle. This code will be very similar to that for the pong game. When the ball bounces off the paddle or the ceiling, the x-component of the speed should stay the same, but the y-component should reverse. Similarly when the ball hits a wall, the y-component should stay the same, while the x-component reverses. (Emulate the code for Pong to accomplish this.)

  Each time the ball bounces off something it should create a bounce noise. We have provided you with a "bounce" noise inside your start-up folder. The startup version of class BrickOut contains code to initialize a variable bounceSound of type AudioClip to hold the sound. The sound will be generated if you send a message play() to bounceSound. Of course the MovingBall object will know when to play the sound, so you might as well make it responsible for calling play() at the appropriate time.

  At this stage the ball should simply pass through the bricks without noticing their existence. Don't worry now about the possibility of more than one ball bouncing around the court. However, avoid creating more than one while testing the programs as it may cause problems when you are removing bricks.

• Implement the method:

      public boolean bounce(FilledOval ball)
      

  of BrickSet. To determine whether the ball should bounce off of one or more bricks, check to see if any of the four corners of the rectangle surrounding the ball is contained in any of the bricks in the court. If the upper left corner of the ball is at (x,y), then the other corners will be at the coordinates shown in the picture below if the radius of the ball is r.

  

  The private method:

      private Slot getElementAt(x,y)
      

  that we have provided for you in class BrickSet should be helpful in determining the brick (if any) at each location (x,y). The method returns null if there is no brick at that place. Remove each of the bricks touching the ball from the canvas and set the corresponding entry in the array to null to indicate that the brick is no longer there. Notice that more than one brick may disappear if the ball touches all of them simultaneously. The method should return true exactly when one or more bricks disappears because of this check.

  Now use the bounce method in the run method of MovingBall to determine if the ball bounces off of a brick. If the ball bounces off a brick it reverses its y-component of the speed, but the x-component stays the same. (I realize that this does not exactly match the physics, but it makes things easier for you.)

• Detect when all of the bricks have been destroyed and then placing a message on the canvas indicating that the player has won.
• Figure out a way of making sure that if the user clicks while a ball is still bouncing then a new ball will not be generated. It is easy to set a boolean variable in the BrickOut class when a ball is created, but it is a little tricker to reset it when a ball stops bouncing. Consider how to send a message from the moving ball back to your BrickOut object to reset the boolean so that the applet knows to allow another ball to be created when the user clicks on the canvas.

  Keep track of the number of balls generated so that the game ends when three balls have been lost.

• Add a JLabel on the bottom of the window. It should keep a running count of the number of bricks left in the window and the number of balls left to be created before the game ends. See the sample program to see how that is updated during the game.
• After a game is completed, allow a user to start a new game by clicking on the window. (See the demo program.) If a new program is started, any bricks left on the window should be removed before a new set is created and displayed.

There is a great deal of functionality to aim for in this test program. Do not worry if you cannot implement all of the functionality. Get as much of it working as you can. As we have done throughout the semester, we will consider both issues of correctness and the quality of your code when grading your program. It is always best to have full functionality, but you are better off having most of the functionality and a beautifully organized program than all of the functionality with a program that is sloppy, poorly commented, etc.

Extra Points

We have deliberately left out many features of some of the fancier versions of Brickout. As a result, there are many additional features you could add to your program. We will give 1-2 points for each extension, for a maximum of 6 points extra credit. Some possible extensions are:

• Improve the user control over how the ball bounces off of the paddle. You will notice that in my version of the game the ball will reverse x and y directions if it bounces off of the side of my paddle. The criteria I use is whether at the time of a collision the center of the ball is to the left of the left edge of the paddle or if the center of the ball is to the right of the right edge of the paddle. Adding this feature will net you two points extra credit.
• Make the game more challenging as you play. Speed up the velocity of the ball slightly every seventh time it hits the paddle. This is worth one extra point.
• If the player correctly clears the field, create a new collection of bricks a bit closer to the paddle and allow the player to restart the current ball (probably this should be combined with the previous suggestions of speeding up the ball). This is worth one extra point.
• Keep a file of players who have successfully destroyed all of the bricks while playing the game. Start your program initially with an empty file called something like highscores.txt. When someone wins, open the file and read the contents to a string which can be printed or displayed. Prompt the user to type their name into a dialog box by executing a statement like the following:

      String name = JOptionPane.showInputDialog("Please type your name");
      

  You can then add name to the string and write it back to the file. This is worth two extra points. Make it even more interesting by keeping track of all of the number of bricks destroyed if you've added the feature of creating more bricks when all of the original bricks have been destroyed.

• Look at some of the other on-line versions of BrickOut or BreakOut and add some of their features. I'm happy to let you know how many points any of your suggested enhancements might be worth.

Please do keep in mind that creating a well structured and well documented program that meets the regular requirements for the assignment is worth much more than the extra credit features.

Turning it in

Your design should be either neatly written or typed, and it should be turned in on paper at the beginning of class on Wednesday, April 30th. We will NOT return the design to you before the program is due. Thus you should keep a copy of your design.

Submit your code in the usual way by exporting and dragging your project into the Dropoff folder for your section. Name your folder with your last name followed by TP2. Also, be sure to double check your work for correctness, organization and style.

This program is due at 4 p.m. on May 7th, the last day of classes. While you may turn your program in late, you will be assessed a 10 point penalty for each day it is late. I.e., if you turn it in by 4 p.m. on May 8th, you will receive a 10 point penalty. If you turn it in at 4 p.m. on May 9th, you will receive a 20 point penalty, etc.

Computer Science 051
Department of Computer Science
Pomona College