here is the remix i made for the breakout game. i wanna show this on each side of the box. here is the link to the zip file. I also have a problem my brick keep flickering or disappearing.any solution to that?
game mod remix

i can post the code here but very long
here is the main code that is calling all the classes

1. /********************GLOBAL VARIABLES********************************************/
2. // variable of type Rectangle:
3. //This variable represents the game "board" - a game is played within the gameFrame...
4. float r = random (0, 255);
5. float g = random (0, 255);
6. float b = random (0, 255);
7. Rectangle gameFrame;
8. // variable to hold an array of objects of type Brick
9. Brick[] bricks;
10. // variable of type Paddle that represents a paddle
11. Paddle paddle;
12. // variable to hold an array of objects of type Ball
13. Ball[] balls;
14. int frameNum = 0;
15. // THE SCREEN PROPERTIES :
16. int screenWidth = 800;
17. int screenHeight = 400;
18. color backgroundColor = #333F48;
19. boolean backgroundRefreshes = true;
20. // THE GAME FRAME PROPERTIES:
21. int gameFrameWidth = 400;
22. int gameFrameHeight = 400;
23. color gameFrameStroke = #333F48;
24. boolean gameFrameHasStroke = false;
25. color gameFrameFill = #333F48;
26. int opacityOfRefresh = 255;
27. boolean gameFrameRefreshes = true;
28. float spin = 0.0;
29. int recX = (screenWidth-gameFrameWidth)/2;
30. int recY = (screenHeight-gameFrameHeight)/2;
31. /********************SET UP FUNCTION********************************************
32.  This function sets up the startup properties for a new game session
33.  - occurs before a new game starts
34.  ******************************************************************************/
35. void setup() {
36.   size(screenWidth, screenHeight, P3D);
37.   background(r, g, b);
38.   frameRate(60);
39.   // Instantiate the necessary objects for a new game
40.   // create a rectanle object to represnt the game frame
41.   gameFrame = new Rectangle(gameFrameWidth, gameFrameHeight, gameFrameHasStroke, gameFrameStroke, true, gameFrameFill);
42.   gameFrame.opacity = opacityOfRefresh;
43.   // call the function to create the Bricks for a new game session
44.   createBricks();
45.   // call the function to create the Balls for a new game session
46.   createBalls();
47.   paddle = new Paddle();
48.   // call the function to refresh the screen
49.   refreshScreen();
50. }
51. /********************DRAW FUNCTION*******************************************
52.  This function is the function that starts a new game and the progam will
53.  continuously loop in this function for the duration of the program lifecycle
54.  - (until we quit a game)
55.  ***************************************************************************/
56. void draw() {
57.  
58. //  translate(width, height/2, 50);
59. //  rotateY(map(mouseX, 0, width, 0, PI));
60. //  rotateX(map(mouseY, 0, height, 0, PI));
61. //  box(150);
62.  rotateX(radians(35));
63.  rotateZ(radians(10));
64.  translate(50,-170,20);
65.  rotateY(radians(25));
66. // scale(.9);
67. // rotateZ(radians(28));
68. //  translate(110, -200);
69.   // call the refreshScreen function
70.   //(will update all the necessary properties, objects and game state)
71.   refreshScreen();
72.   // call saveScreenShots()
73.   saveScreenshots();
74. }
75. /********************createBalls() FUNCTION**********************************
76.  This function is called when we want to define and create the balls.
77.  This function takes no arguements and does not return anything
78.  ***************************************************************************/
79. void createBalls() {
80.   // Local Variables for Ball Properties
81.   //make changes here to the ball numbers
82.   int numberOfBalls = 30;
83.   int yBalls = 60;
84.   //assign the balls variable to be an array of Ball objects -
85.   //the array will hold "numberOfBalls" = 1 object ( have only 1 ball at the time in a game)
86.   balls = new Ball[numberOfBalls];
87.   for (int i=0; i<numberOfBalls; i++) {
88.     int x = i*20;
89.      /***** This line is fundamental: as it will create a new Ball object with the specified parameters
90.     and will put the instantiated Ball object into our "ball" array.************************************/
91.     balls[i] = new Ball(x, yBalls);
92.   }
93. }
94. /********************createBricks() FUNCTION**********************************
95. This function is called when we want to define and create the bricks
96. The function takes no arguments and does not return anything
97. ****************************************************************************/
98. void createBricks() {
99.   // Local Variables for Brick Group Properties
100.   int numberOfBricks = 80;//80 make change here
101.   int bricksPerRow = 6; //6 make change here
102.   int brickWidth = gameFrameWidth/bricksPerRow;
103.   int brickHeight = 20; //60 make change here
104.   boolean brickHasStroke = false;
105.   color brickStroke = #8E8B82; //60 make change here
106.   boolean brickHasFill = true;
107.   color brickFill = #ff0000; //60 make change here
108.   int yBricks = 50;
109.   //make change here
110.   color[] rowsColors = {
111.     #01DAF5, #A6D7DE, #ff9900, #ff9900, #00DAF5, #ff9900, #00DAF5
112.   };
113.  
114.   // Create the bricks
115.   //assign the brick variable to be an array of Brick objects - the array will hold "numberOfBricks" =60 objects
116.   bricks = new Brick[numberOfBricks];
117.   // use a for loop to put 60 Brick objects into the array named "brick"
118.   for (int i=0; i<numberOfBricks; i++)
119.   {
120.     // to keep track of the row we are on
121.     int rowNum = i/bricksPerRow;
122.     // coords for creating a brick
123.     int x = brickWidth*i;
124.     x -= rowNum*bricksPerRow*brickWidth;
125.     int y = yBricks+i/bricksPerRow*brickHeight;
126.     // variable used for determination of the colour of a brick
127.     // rowColors = an array of colors
128.     // min() is an inbuilt function which will return the minimum value between its two arguements
129.     int num = min(rowNum, rowsColors.length-1);
130.     // choose a colour based on the value of num
131.     color rowColor = rowsColors[num];
132.     /***** This line is fundamental: as it will create a new Brick object with the specified parameters
133.      and will put the instantiated Brick object into our "bricks" array.************************************/
134.     bricks[i] = new Brick(x, y, brickWidth, brickHeight, brickHasStroke, brickStroke, brickHasFill, rowColor);
135.   }
136. }
137. /********************refreshScreen() FUNCTION**********************************
138.  This function is called when we want to refresh the game properties and/or update
139.  the state of the game.
140.  This function takes no arguements and does not return anything
141.  ******************************************************************************/
142. void refreshScreen() {
143.   // condition for refreshing the Background
144.   // check if this (global) boolean is TRUE...
145.   if (backgroundRefreshes) {
146.     background (backgroundColor);
147.     //background(r,g,b);
148.   }
149.   // condition for refreshing the GameFrame
150.   // check if this (global) boolean is TRUE...
151.   if (gameFrameRefreshes) {
152.     // call this function: located in the Rectangle class - because the gameFrame is an object of type Rectangle
153.     gameFrame.drawYourself();
154.   }
155.   // PADDLE
156.   // Update paddle Properties
157.   // call the refresh() function for the Paddle object (the function is in the Paddle class...)
158.   paddle.refresh();
159.   // BRICKS
160.   // Update the bricks array
161.   // within the for loop call the refresh() function for every Brick oject currently within the bricks array
162.   //(the function is within the Bricks class...)
163.   for (int i=0; i<bricks.length; i++) {
164.     bricks[i].refresh();
165.   }
166.   // BALLS
167.   //Update the balls array
168.   // within the for loop call the refresh() function for every Ball oject currently within the balls array
169.   //(the function is within the Ball class...)
170.   for (int i=0; i<balls.length; i++) {
171.     balls[i].refresh();
172.   }
173. }
174. /********************saveScreenShots() FUNCTION**********************************
175.  This function is for saving screen shots of the game ...
176.  Be careful with this function - only change if you know what you're doing
177.  the hard disk could fill up with images in a few minutes
178.  press the 'G' key to save frames in TGA pictures in 'saved' folder
179.  *******************************************************************************/
180. void saveScreenshots() {
181.   frameNum++;
182.   if (keyPressed) {
183.     if (key == 'g' || key == 'G') {
184.       if (frameNum%2==0) {
185.         saveFrame("saved/frame-####.tga");
186.       }
187.     }
188.   }
189. }

this is ball class

1. // import the necessary library
2. import java.awt.geom.*;
3. /********************************************************************************
4.  Defintion of the Ball Class:
5.  The Ball class has dual functionality:
6.  First: It is used to create an instance of a ball object
7.  Second: A ball instance will detect if it is touching a brick,
8.  the paddle or the bounding limits of the game frame. Therefore the ball class contains
9.  the necessary functions for detecting any collision with the other above mentioned
10.  objects that are instantiated in the game session ...
11.  *********************************************************************************/
12. public class Ball {
13.   // Define an a local variable "rectangle" to represent an object of type Rectangle
14.   Rectangle rectangle;
15.   // local Variables that represent the properties of a Brick object
16.   int width = 10; // make change here to the ball
17.   int height = 10; // make change here to the ball
18.   boolean hasStroke = true;
19.   color strokeColor = #550F48; //#333F48 make change here
20.   boolean hasFill = true;
21.   color fillColor = #102F48; //#333F48 make change here
22.   // velocity
23.   int velX = 4; //4 make change here
24.   int velY = 2; //4 make change here
25.   // positioning variables
26.   int x;
27.   int y;
28.   int ox;
29.   int oy;
30.   int xcentre;
31.   int ycentre;
32.   /********************************************************************************
33.    Ball Class Default Constructor:
34.    In order to create an Instance of a Ball Object, one needs to invoke
35.    the Default Constructor in the following manner: new Ball(tempX,tempY).
36.    The Ball Constructor makes an instance of the Rectangle Class.
37.   /********************************************************************************/
38.   Ball(int newX, int newY) {
39.     x = newX;
40.     y = newY;
41.     // make an instance of the Rectangle object (the ball is a rectangle...)
42.     rectangle = new Rectangle(width, height, hasStroke, strokeColor, hasFill, fillColor);
43.     // call the setPosition() function of the rectangle ( the function is within the Rectangle class...)
44.     rectangle.setPosition(x, y);
45.    
46.   }
47.   /********************************************************************************
48.    Function: refresh()
49.    Returns: nothing.
50.    Maintains the state of the given Ball on the Screen.
51.    The refresh() method calls the updatePosition() method, and there after
52.    the setPosition() and finally redraws itself to the screen (with the drawYourself()).
53.    **********************************************************************************/
54.   void refresh() {
55.     // call this function that is local to this class
56.     updatePosition();
57.     rectangle.setPosition(x, y);
58.     rectangle.drawYourself();
59.     // Remember that a Brick has been defined as an object rectangle of type Rectangle.
60.     // Therefore the drawYourself()&setPosition() functions are within the Rectangle Class...
61.   }
62.   /********************************************************************************
63.    Function: updatePosition()
64.    Returns: nothing.
65.    Calculates the "real" time positioing of the Ball. Within this function
66.    are also the calls to the function to check if the ball
67.    has collided with another object.
68.    *********************************************************************************/
69.   void updatePosition() {
70.     // add velocity to position- this simulates the ball movemnet( we update the x and y position of the ball...
71.     x+=velX;
72.     y+=velY;
73.     // collision with limits for "x"
74.     if (x<=0 || x>=gameFrameWidth-width) {
75.        // set the velocity for the x Position
76.       velX = -velX;
77.       // the constrain() will make sure that "x" does not go less than 0 and not greater than (gameFrameWidth-width)
78.       x = constrain(x, 0, gameFrameWidth-width);
79.     }
80.     // collision with limits for "y"
81.     if (y<=0 || y>=gameFrameHeight-height) {
82.       velY = -velY;
83.       y = constrain(y, 0, gameFrameHeight-height);
84.     }
85.     xcentre = x+width/2;
86.     ycentre = y+height/2;
87.    
88.     // We check if the ball is colliding with the paddle
89.     // input parameter is the "rectangle" variables defined in the Paddle class
90.     // Remember: the "paddle" is an object of type Paddle - and this class has an instance variable named "rectangle" ...
91.     // This function will return "result"
92.     // collision with paddle
93.     int result = checkCollisionWithRectangle(paddle.rectangle);
94.     // if collides on top, control direction of ball
95.     //  if (result == 1){
96.     //if(xcentre < paddle.rectangle.x1+paddle.rectangle.width/2){
97.     // if(velX>0){
98.     //  velX = -velX*2;
99.     // }
100.     //  }else{
101.     //  if(velX<0){
102.     //  velX = -velX/3;
103.     //}
104.     //}
105.     // }
106.     //We detect collision with the bricks if the result is "0"
107.     if (result == 0) {
108.       // iterate through the array of Bricks
109.       for (int i=0; i<bricks.length; i++) {
110.          // Check  if the brick is alive ( imAlive is a boolean -  so if TRUE...)
111.         if (bricks[i].imAlive) {
112.           /*We check if the ball is collidiing with the paddle
113.             Input parameter is the "rectangle" variables defined in the Brick class
114.             Remember: the "bricks[i]" is an object of type Brick - and this class has
115.             an instance variable named "rectangle" (Every brick instance has its own "rectangle" var)*/
116.             // This function will return "res"
117.           int res = checkCollisionWithRectangle(bricks[i].rectangle);
118.           // if the returned "res" s not 0 then kill this brick.
119.           if (res != 0) {
120.             bricks[i].die();
121.             break;
122.           }
123.         }
124.       }
125.     }
126.     // keep track of the current x and y vars (make a copy)
127.     ox = x;
128.     oy = y;
129.   }
130.   /********************************************************************************
131.     Function: checkCollisionWithRectangle()
132.     Input Paramer: A Rectangle "tempRect"
133.     Returns: an integer:
134.     result: 0: no collision 1: top 2: right 3: bottom 4: left 5: couldn't detect which side
135.  *********************************************************************************/
136.   int checkCollisionWithRectangle (Rectangle R) {
137.     // define the result variable
138.     int result = 0;
139.     // check if the rectangle given (ie the paddle) is being touched by the ball
140.     // xcentre, ycentre are ball position variables
141.     // doesPointTouchMe() is located in the Rectangle class...
142.     // if it returns TRUE then execute this clause
143.     if (R.doesPointTouchMe(xcentre, ycentre)) {
144.       //check which side of the tempRect object has the ball touched.
145.       // This line is easier to work with when we want to check how
146.       //the ball has collided with the Rectangle object instead of using the ball itself...
147.       Line2D lineaBola = new Line2D.Float(xcentre, ycentre, ox+width/2, oy+height/2);
148.       // whatSideDoesLineTouch() is located in the Rectangle class...
149.     // if it returns TRUE then execute this clause
150.       result = R.whatSideDoesLineTouch(lineaBola, velX, velY);
151.       // have to perhaps change the position & velocity parameters of the ball
152.       // top
153.       if (result==1) {
154.         velY = -velY;
155.         y = R.y1-height;
156.         // right
157.       }
158.       else if (result==2) {
159.         velX = -velX;
160.         x = R.x2;
161.         // bottom
162.       }
163.       else if (result==3) {
164.         velY = -velY;
165.         y = R.y2;
166.         // left
167.       }
168.       else if (result==4) {
169.         velX = -velX;
170.         x = R.x1-width;
171.       }
172.       else {
173.         result = 20;
174.       }
175.     }
176.     // return the correct result ... also remember
177.     //if this result!=0 then the brick touched will die...
178.     return result;
179.   }
180. /*********************************************************************************/
181. }// End of Ball Class Definition

Brick class

1. /********************************************************************************
2.  Defintion of the Brick Class:
3.  The Brick Class is used to define a Brick object in the game.
4.  It makes use of the Rectangle Class.
5.  **********************************************************************************/
6. public class Brick
7. {
8.   // Define an a local variable "rectangle" to represent an object of type Rectangle
9.   Rectangle rectangle;
10.   // local Variables that represent the properties of a Brick object
11.   boolean hasStroke = true; //make change here
12.   color strokeColor = 0; // make change here
13.   boolean hasFill = true; //make change here
14.   color fillColor = 157; // make change here
15.   //
16.   int x = 500; //make change here
17.   int y = 100; //make change here
18.   //
19.   boolean respawns = true; //make change here
20.   int timeToRespawn = 20; // time is in frames
21.   // time is in frames
22.   int frame;
23.   boolean imAlive;
24.   /********************************************************************************
25.    Brick Class Default Constructor:
26.    In order to create an Instance of a Brick Object, one needs to invoke
27.    the Default Constructor in the following manner:
28.    new Brick(rectX, rectY, rectWidth,rectHeight, hasStroke, strokeDef, hasFill, fillColour).
29.    The Brick Constructor makes an instance of the Rectangle Class.
30.   /********************************************************************************/
31.   Brick(int X, int Y, int W, int H, boolean HASSTROKE, color STROKE, boolean HASFILL, color FILL) {
32.     // make an instance of the Rectangle object
33.     rectangle = new Rectangle(W, H, HASSTROKE, STROKE, HASFILL, FILL);
34.     // call the setPosition() function of the rectangle ( the function is within the Rectangle class...)
35.     rectangle.setPosition(X, Y);
36.     imAlive = false;
37.   }
38.   /********************************************************************************
39.    Function: refresh()
40.    Returns: nothing.
41.    Maintains the state of the given Brick on the Screen.
42.    The refresh() method checks the state of the Brick (alive or dead)
43.    / if a new one should be created - if it is alive it will call the drawYourself().
44.    **********************************************************************************/
45.   void refresh() {
46.     if (imAlive) {
47.       // Remember that a Brick has been defined as an object rectangle of type Rectangle.
48.       // Therefore the drawYourself() function is within the Rectangle Class...
49.       rectangle.drawYourself();
50.     }
51.     else {
52.       if (respawns) {
53.         frame++;
54.         if (frame>timeToRespawn-10) {
55.           // rise up from your grave, brick
56.           imAlive=true;
57.         }
58.       }
59.     }
60.   }
61. /********************************************************************************
62.     Function: die()
63.     Returns: nothing.
64.     Maintains the state of a Brick. If a Brick is "dead", it is removed from the screen.
65.  *********************************************************************************/
66.   void die() {
67.     imAlive = false;
68.     frame = 2;
69.   }
70. }// End of Brick Class Definition

paddle class

/********************************************************************************
 Defintion of the Paddle Class:
 The Paddle Class is used to define the Paddle object in the game.
 It makes use of the Rectangle Class.
 *********************************************************************************/

public class Paddle {

1.   /********************************************************************************
2.    Paddle Class Instance Variables:
3.    These Instance Variables will be initialised(defined)when an Instance of the
4.    Paddle Class is invoked by calling the default constructor new Paddle().
5.   /*********************************************************************************/
6.   // Define an a local variable "rectangle" to represent an object of type Rectangle
7.   Rectangle rectangle;
8.   // Paddle Variables
9.   int width = 200;
10.   int height = 50;
11.   // boolean variables
12.   boolean hasStroke = false;
13.   boolean hasFill = true;
14.   // color variables make change here
15.   //#333F48
16.   color strokeColor = #102F48;
17.   //#333F48
18.   color fillColor = #100F48;
19.   //
20.   int x = gameFrameWidth/2;
21.   int y = 370;
22.   /********************************************************************************
23.    Paddle Class Default Constructor -
24.    In order to create an Instance of a Paddle Object, one needs to invoke
25.    the Default Constructor in the following manner new Paddle().
26.    The Paddle Class makes an instance of the Rectangle Class.
27.    *********************************************************************************/
28.   Paddle() {
29.     rectangle = new Rectangle(width, height, hasStroke, strokeColor, hasFill, fillColor);
30.     rectangle.setPosition(x, y);
31.   }
32.   /********************************************************************************
33.    Function: refresh()
34.    Returns: nothing.
35.    Maintains the Position of the Paddle on the Screen. 
36.    The refresh() method call the updatePosition() method, and there after
37.    the setPosition() and redraws itself to the screen (with the drawYourself()).
38.   /******************************************************************************** */
39.   void refresh() {
40.     updatePosition();
41.     // Update the Position of the Rectangle (Paddle) Object
42.     // this function is in THIS class...
43.     rectangle.setPosition(x, y);
44.     // now set the position ...
45.     rectangle.drawYourself();
46.     // Remember that a Paddle has been defined as an object rectangle of type Rectangle.
47.     // Therefore the drawYourself() function is within the Rectangle Class...
48.   }
49. /********************************************************************************
50.     Function: updatePosition()
51.     Returns: nothing.
52.     Calculates the "real" time positioning of the Paddle.
53.  *********************************************************************************/
54.   void updatePosition() {
55.     x = mouseX-recX-width/2;
56.     x = constrain(x, 0, gameFrameWidth-width);
57.   }
58. /********************************************************************************/
59. }  // End of Paddle Class Definition

rectangle class

1. // import the necessary library
2. import java.awt.geom.*;
3. /********************************************************************************
4.  Defintion of the Rectangle Class:
5.  The Rectangle Class is used to define every visible object in the game
6.  (The game frame, the bricks, the paddle and the ball)
7.  *********************************************************************************/
8. public class Rectangle {
9.   int width;
10.   int height;
11.   //change here for the color
12.   boolean hasStroke = false;
13.   color strokeColor;
14.   boolean hasFill = true;
15.   color fillColor;
16.   color opacity;
17.   int x1;
18.   int y1;
19.   int x2;
20.   int y2;
21.   /********************************************************************************
22.    Rectangle Class Default Constructor -
23.    In order to create an Instance of a Rectangle Object,
24.    one needs to invoke the Default Constructor in the following manner:
25.    Rectangle myRectangle = new Rectangle(rectWidth, rectHeight, temp_hasStroke,temp_strokeColor,temp_hasFill,temp_fillColor)
26.   /*********************************************************************************/
27.   Rectangle(int widthOfRect, int heightOfRect, boolean hasStroke, color strokeColor, boolean fillIsHere, color tempFILL) {
28.     // set the values of the instance variables to the given arguements.
29.     width = widthOfRect;
30.     height = heightOfRect;
31.     hasStroke = hasStroke;
32.     strokeColor = strokeColor;
33.     hasFill = fillIsHere;
34.     fillColor = tempFILL;
35.     //change here 205
36.     opacity = 505;
37.   }
38.   /*********************************************************************************
39.    Function: setPosition(int posX, int posY)
40.    Returns: nothing.
41.    Set the position of the Rectangle Instance Object and defines the dimensions
42.    *********************************************************************************/
43.   void setPosition(int newX, int newY) {
44.     x1 = newX;
45.     y1 = newY;
46.     x2 = x1+width;
47.     y2 = y1+height;
48.   }
49.   /*********************************************************************************
50.    Function: drawYourself()
51.    Returns: nothing.
52.    The drawYourself() function is invoked each time the Rectangle is to be drawn on the Screen.
53.    The drawYourself() function also checks and applies styling parameters to the Rectangle
54.    i.e. Stroke, Fill and the of Dimensions a rectangle.
55.    It will also call the inbuilt rect() to draw the shape to the screen...
56.    *********************************************************************************/
57.   void drawYourself() {
58.     // Check if this Rectangle has to a stroke property enabled, if so, apply the stroke property.
59.     if (hasStroke) {
60.       stroke(strokeColor);
61.     }
62.     else {
63.       noStroke();
64.     }
65.     // Check if this Rectangle is fill property enabled, if so, apply the fill property.
66.     if (hasFill) {
67.       fill(fillColor, opacity);
68.     }
69.     else {
70.       noFill();
71.     }
72.     // Draw the Rectangle and enabled propoerties. make change here
73.     rect(recX+x1, recY+y1, width/2, height/2);
74.   }
75.   /*********************************************************************************
76.    Function: doesPointTouchMe()
77.    Returns: boolean.
78.    The doesPointTouchMe Method implements a collision detetction algorithm, if the points (pX, pY)
79.    are discovered to be within the bounds of the Rectangle Object(i.e a Brick, Paddle...).
80.    Then the object (ball object) represented by position (pX, pY), indeed touches that Rectangle object.
81.    *********************************************************************************/
82.   boolean doesPointTouchMe (int PX, int PY) {
83.     // Set the return variable to false, assume that the Rectangle is not Touched.
84.     boolean result = false;
85.     // Check the if pX is found inside the x coordinates of the current Rectangle
86.     if (PX >= x1 && PX <= x2) {
87.       // Check if pY is found inside the y coordinates of the current Rectangle
88.       if (PY >= y1 && PY <= y2) {
89.         // If we reach this statement, then the Rectangle has been Touched.
90.         result = true;
91.       }
92.     }
93.     return result;
94.   }
95.  
96.   /*********************************************************************************
97.    Function: whatSideDoesLineTouch()
98.    Input Parameters: tempLine (represents the side of the ball that has touched the other Rectangle object)
99.    velX, velY (velocity parameters of the ball)
100.    Returns: an int (represnts the side of the touched Rectangle oject) - touched BY the ball..
101.    This function determines which side of the Rectangle object that called this function (i.e. a Brick)
102.    has been touched by the Ball object
103.   /*********************************************************************************/
104.   int whatSideDoesLineTouch (Line2D LINE, int VELX, int VELY) {
105.     // local variable to represent the side
106.     Line2D side;
107.     // condition check based on velY value
108.        // top touched will return (1) and bottom touched will return(3)
109.     if (VELY>0) {
110.       // create an instance of a 2D Line
111.       side = new Line2D.Float(x1, y1, x2, y1);
112.       // check if our line representing the side of the "ball" intersects the side.
113.         // Note: the function intersectsLine is deined in the Line2D class which is from the
114.         // java.awt.geom library
115.       if (LINE.intersectsLine(side)) {
116.         return 1;
117.       }
118.     }
119.     else if (VELY<0) {
120.       side = new Line2D.Float(x1, y2, x2, y2);
121.       if (LINE.intersectsLine(side)) {
122.         return 3;
123.       }
124.     }
125.     // left touched will return (4) / right touched will return (2)
126.     if (VELX>0) {
127.       side = new Line2D.Float(x1, y1, x1, y2);
128.       if (LINE.intersectsLine(side)) {
129.         return 4;
130.       }
131.     }
132.     else if (VELX<0) {
133.       side = new Line2D.Float(x2, y1, x2, y2);
134.       if (LINE.intersectsLine(side)) {
135.         return 2;
136.       }
137.     }
138.     return 0;
139.   }
140. }