Question

Create a Java application that creates a window in which multiple bouncing balls can be animated.

have attached a text file of the source found on that site. You can paste the entire application into an Eclipse source file named BounceThread.java and it will compile and run. Optionally, you may prefer to put some or all of the classes into separate files to organize your work.

Your task is to add the following capability to the application:

(5%)    Increase the time that a ball bounces by a factor of 3.
(15%) Randomly select a new color for each new ball; you may use RGB values or just randomly select one of the 13 Java predefined colors
(15%) Randomly select an initial direction for each new ball
(16%) A slide control that changes the speed of ball movement
(16%) Radio buttons that will choose between a small, medium, and large size ball (size choice is yours).
(18%) Add shadows; as a ball moves, draw a black filled oval at the bottom of the JPanel.
(15%) Make the ball appear to recede as it bounces; each time it hits the edge of the JPanel decrease it's size

When the start button is pressed the current settings will used for the ball object. Once a ball object is instantiated and animated, the controls may be ignored. That is, you do not have to change the speed or size of the current ball(s) on the fly if the controls are changed. However, if the controls are changed and start is pressed again, the new ball should reflect the latest settings.

Here is the code that I have so far.

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Container;

import java.awt.EventQueue;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.geom.Ellipse2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JFrame;

import javax.swing.JPanel;

/** * Shows animated bouncing balls.*/

public class BounceThread {

public static void main(String[] args) {

    EventQueue.invokeLater(new Runnable() {

      public void run() {

        JFrame frame = new BounceFrame();

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.setVisible(true);

      }

    });

}

}

/**

* A runnable that animates a bouncing ball.

*/

class BallRunnable implements Runnable {

/**

   * Constructs the runnable.

   *

   * @aBall the ball to bounce

   * @aPanel the component in which the ball bounces

   */

public BallRunnable(Ball aBall, Component aComponent) {

    ball = aBall;

    component = aComponent;

}

public void run() {

    try {

      for (int i = 1; i <= STEPS; i++) {

        ball.move(component.getBounds());

        component.repaint();

        Thread.sleep(DELAY);

      }

    } catch (InterruptedException e) {

    }

}

private Ball ball;

private Component component;

public static final int STEPS = 1000;

public static final int DELAY = 5;

}

/**

* The frame with panel and buttons.

*/

class BounceFrame extends JFrame {

/**

   * Constructs the frame with the component for showing the bouncing ball and

   * Start and Close buttons

   */

public BounceFrame() {

    setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

    setTitle("BounceThread");

    comp = new BallComponent();

    add(comp, BorderLayout.CENTER);

    JPanel buttonPanel = new JPanel();

    addButton(buttonPanel, "Start", new ActionListener() {

      public void actionPerformed(ActionEvent event) {

        addBall();

      }

    });

    addButton(buttonPanel, "Close", new ActionListener() {

      public void actionPerformed(ActionEvent event) {

        System.exit(0);

      }

    });

    add(buttonPanel, BorderLayout.SOUTH);

}

/**

   * Adds a button to a container.

   *

   * @param c

   *          the container

   * @param title

   *          the button title

   * @param listener* the action listener for the button*/

public void addButton(Container c, String title, ActionListener listener) {

    JButton button = new JButton(title);

    c.add(button);

    button.addActionListener(listener);

}

/** Adds a bouncing ball to the canvas and starts a thread to make it bounce*/

public void addBall() {

    Ball b = new Ball();

    comp.add(b);

    Runnable r = new BallRunnable(b, comp);

    Thread t = new Thread(r);

    t.start();

}

private BallComponent comp;

public static final int DEFAULT_WIDTH = 450;

public static final int DEFAULT_HEIGHT = 350;

public static final int STEPS = 1000;

public static final int DELAY = 3;

}

/*** The component that draws the balls.

class BallComponent extends JComponent {

/*** Add a ball to the panel.** @param b

   *the ball to add*/

public void add(Ball b) {

    balls.add(b);

}

public void paintComponent(Graphics g) {

    Graphics2D g2 = (Graphics2D) g;

    for (Ball b : balls) {

      g2.fill(b.getShape());

    }

}

private ArrayList<Ball> balls = new ArrayList<Ball>();

}

class Ball {

/**

   * Moves the ball to the next position, reversing direction if it hits one of* the edges*/

public void move(Rectangle2D bounds) {

    x += dx;

    y += dy;

    if (x < bounds.getMinX()) {

      x = bounds.getMinX();

      dx = -dx;

    }

    if (x + XSIZE >= bounds.getMaxX()) {

      x = bounds.getMaxX() - XSIZE;

      dx = -dx;

    }

    if (y < bounds.getMinY()) {

      y = bounds.getMinY();

      dy = -dy;

    }

    if (y + YSIZE >= bounds.getMaxY()) {

      y = bounds.getMaxY() - YSIZE;

      dy = -dy;

    }

}

/*** Gets the shape of the ball at its current position*/

public Ellipse2D getShape() {

    return new Ellipse2D.Double(x, y, XSIZE, YSIZE);

}

private static final int XSIZE = 15;

private static final int YSIZE = 15;

private double x = 0;

private double y = 0;

private double dx = 1;

private double dy = 1;

}

Answer 1

import java.awt.*;

import java.util.Formatter;

import javax.swing.*;

public class BouncingBallSimple extends JPanel {

   private static final int BOX_WIDTH = 640;

   private static final int BOX_HEIGHT = 480;

   private float ballRadius = 200;

   private float ballX = ballRadius + 50;

   private float ballY = ballRadius + 20;

   private float ballSpeedX = 3;  

   private float ballSpeedY = 2;

   private static final int UPDATE_RATE = 30;

   public BouncingBallSimple() {

      this.setPreferredSize(new Dimension(BOX_WIDTH, BOX_HEIGHT));

      Thread gameThread = new Thread() {

         public void run() {

            while (true) {

               ballX += ballSpeedX;

               ballY += ballSpeedY;

               if (ballX - ballRadius < 0) {

                  ballSpeedX = -ballSpeedX;

                  ballX = ballRadius;

               } else if (ballX + ballRadius > BOX_WIDTH) {

                  ballSpeedX = -ballSpeedX;

                  ballX = BOX_WIDTH - ballRadius;

               }

               if (ballY - ballRadius < 0) {

                  ballSpeedY = -ballSpeedY;

                  ballY = ballRadius;

               } else if (ballY + ballRadius > BOX_HEIGHT) {

                  ballSpeedY = -ballSpeedY;

                  ballY = BOX_HEIGHT - ballRadius;

               }

               repaint(); // Callback paintComponent()

               try {

                  Thread.sleep(1000 / UPDATE_RATE);

               } catch (InterruptedException ex) { }

            }

         }

      };

      gameThread.start();    }

   @Override

   public void paintComponent(Graphics g) {

      super.paintComponent(g);   

      g.setColor(Color.BLACK);

      g.fillRect(0, 0, BOX_WIDTH, BOX_HEIGHT);

      g.setColor(Color.BLUE);

      g.fillOval((int) (ballX - ballRadius), (int) (ballY - ballRadius),

            (int)(2 * ballRadius), (int)(2 * ballRadius));

      g.setColor(Color.WHITE);

      g.setFont(new Font("Courier New", Font.PLAIN, 12));

      StringBuilder sb = new StringBuilder();

      Formatter formatter = new Formatter(sb);

      formatter.format("Ball @(%3.0f,%3.0f) Speed=(%2.0f,%2.0f)", ballX, ballY,

            ballSpeedX, ballSpeedY);

      g.drawString(sb.toString(), 20, 30);

   }

   public static void main(String[] args) {

      javax.swing.SwingUtilities.invokeLater(new Runnable() {

         public void run() {

            JFrame frame = new JFrame("A Bouncing Ball");

            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

            frame.setContentPane(new BouncingBallSimple());

            frame.pack();

            frame.setVisible(true);

         }

      });

   }

}