Homework SourseCreate a Java application that creates a window in which mul
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;
}
Solution
public class mainClass {
public static class TestBall extends JFrame {
// size of the window
private static final int WINDOW_WIDTH = 500;
private static final int WINDOW_HEIGHT = 300;
// panel containing the bouncing ball
private PanelBall PanelBall;
/**
*/
public static void fn_pause() {
try {
Thread.sleep(10); // fn_pause for 10 ms
} catch (Exception e) {
System.out.println(e);
e.printStackTrace();
}
}//end of fn_pause method
/**
* Creates a new instance of TestBall
*/
public TestBall()
super(\"Ball Bouncing\");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setSize(WINDOW_WIDTH, WINDOW_HEIGHT);
setLayout(new BorderLayout());
PanelBall = new PanelBall();
add(PanelBall);
fn_center(this);
setVisible(true);
while (true) {
fn_pause();
PanelBall.move(PanelBall);
}
} /
/**
public static void fn_center(JFrame frame) {
GraEnv ge = GraEnv.getLocalGraEnv();
Point fn_center = ge.getfn_centerPoint();
int w = frame.getWidth();
int h = frame.getHeight();
int x = fn_center.x - w / 2, y = fn_center.y - h / 2;
frame.setBounds(x, y, w, h);
frame.validate();
}//end of fn_center method
}
public static void main(String[] args) {
TestBall t = new TestBall(); //make a TestBall object
}
}
public class Ball extends JPanel {
private int ballxCoord;
private int ballyCoord;
private int ballHeight;
private int ballwidth;
private int ballRise;
private int ballRun;
private Color ballColor;
//Constructor
public Ball() {
ballxCoord = setStartballxCoord();
ballyCoord = setStartballyCoord();
ballHeight = setStartballHeight();
ballwidth = setStartballwidth();
ballRise = setStartballRise();
ballRun = setStartballRun();
ballColor = setColor();
}
/**
*/
public void setballxCoord(int xCoord) {
ballxCoord = xCoord;
}
public int setStartballxCoord() {
int xCoord;
xCoord = (int) (Math.random() * 51);
return xCoord;
}
public int getballxCoord() {
return ballxCoord;
}
/**
*/
public void setballyCoord(int yCoord) {
ballxCoord = yCoord;
}
public int setStartballyCoord() {
int yCoord;
yCoord = (int) (Math.random() * 51);
return yCoord;
}
public int getballyCoord() {
return ballyCoord;
}
/**
*/
public void setballHeight(int height) {
ballHeight = height;
}
public int setStartballHeight() {
int height;
height = (int) (10 + Math.random() * 11);
return height;
}
public int getballHeight() {
return ballHeight;
}
public void setballwidth(int width) {
ballwidth = width;
}
/**
*/
public int setStartballwidth() {
int width;
width = (int) (10 + Math.random() * 11);
return width;
}
public int getballwidth() {
return ballwidth;
}
/**
*/
public void setballRise(int rise) {
ballRise = rise;
}
public int setStartballRise() {
int rise;
rise = (int) (Math.random() * 11);
return rise;
}
public int getballRise() {
return ballRise;
}
/**
*/
public void setballRun(int run) {
ballRun = run;
}
public int setStartballRun() {
int run;
run = (int) (Math.random() * 11);
return run;
}
public int getballRun() {
return ballRun;
}
/**
*/
public void moveBallX(){
ballxCoord += ballRun;
}
public void moveBallY(){
ballyCoord += ballRise;
}
/**
* The setters, getters, and initial value for the ball\'s color
*/
public void setColor(Color color) {
ballColor = color;
}
public Color setColor() {
int red = (int) (Math.random() * 256);
int green = (int) (Math.random() * 256);
int blue = (int) (Math.random() * 256);
Color ranColor = new Color(red, green, blue);
return ranColor;
}
public Color getballColor() {
return ballColor;
}
/**
*/
public void move(PanelBall PanelBall) {
// If ball is approaching a wall, reverse direction
if ((getballxCoord() < (0 - getballRun())) || (getballxCoord() > (PanelBall.getWidth() - getballwidth()))) {
setballRun(-getballRun());
}
if ((getballyCoord() < (0 - getballRise())) || (getballyCoord() > (PanelBall.getHeight() - getballHeight()))) {
setballRise(-getballRise());
}
moveBallX();
moveBallY();
}
}
public class PanelBall extends JPanel {
Ball ball = new Ball(); //creat a ball.
/**
* Creates a new instance of PanelBall
*/
public PanelBall() {
super();
}
public void move(PanelBall PanelBall) {
ball.move(PanelBall);
repaint();
}
public void paint(Graphics g) {
super.paint(g);
g.setColor(Color.black);
g.fillRect(0, 0, getWidth(), getHeight());
// Paint the Ball
g.setColor(ball.getballColor());
g.fillOval(ball.getballxCoord(), ball.getballyCoord(),
ball.getballwidth(), ball.getballHeight());
}
}//end of PanelBall class
java arrays arraylist
