Create a Java application that creates a window in which multiple bouncing balls
ID: 3793614 • Letter: C
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;
}
Explanation / Answer
Answer:
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class base_frame extends JFrame
{
Container c;
//our components
JPanel b_panel;
JButton b_add,b_sub;
JLabel l_counter,l_ballsize;
JTextField t_ballsize;
//Actionlistener class instance
handler handle;
//class which contains drawing surface "JComponent"
canvas ballcanvas;
base_frame()
{
super("Ball Simulator");
c=getContentPane();
//setting to "flowlayout"
c.setLayout(new FlowLayout());
//all components
t_ballsize=new JTextField(2);
l_counter=new JLabel("Ball Count: ");
l_ballsize=new JLabel("Ball Size: ");
l_counter.setBorder(BorderFactory.createBevelBorder(1));
b_add=new JButton("Add");
b_sub=new JButton("Remove");
handle=new handler();
//adding actionlistener to buttons
b_add.addActionListener(handle);
b_sub.addActionListener(handle);
//button panel
b_panel=new JPanel();//panel to hold buttons,textfields..
b_panel.add(l_ballsize);//label
b_panel.add(t_ballsize);//textfield to input ball size
b_panel.add(b_add);//button to add a ball
b_panel.add(b_sub);//button to del a ball (the most recent one)
b_panel.add(l_counter);//label displaying total balls being rendered
//ball canvas
ballcanvas=new canvas();
//container details
c.add(ballcanvas);//adding drawing surface(ballcanvas) to main jframe
c.add(b_panel);//adding the panel along with its smaller components
//set visuals
setSize(640,480);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
public static void main(String[] args)
{
new base_frame();//creating main jframe instance
}
//an inner class to take care of button events
class handler implements ActionListener
{
public void actionPerformed(ActionEvent ae)
{
//if "Add" button clicked
if(ae.getSource()==b_add)
{
if(!t_ballsize.getText().equals(""))
{
try{
ballcanvas.addBall(Integer.parseInt(t_ballsize.getText()));
//updates the counter label
l_counter.setText("Ball Count:"+ballcanvas.countBall());
}catch(NumberFormatException e)
{
System.out.println(e);
JOptionPane.showMessageDialog(null,"Enter only numbers!","Invalid Input",JOptionPane.INFORMATION_MESSAGE);
}
}
else
{
JOptionPane.showMessageDialog(null,"Enter the ball size!","Input needed",JOptionPane.INFORMATION_MESSAGE);
}
}//b_add
//if "Sub" button clicked
if(ae.getSource()==b_sub)
{
ballcanvas.removeBall();
//updates the counter label
l_counter.setText("Ball Count:"+ballcanvas.countBall());
}
}
}
}
import java.awt.*;
import javax.swing.*;
import java.util.*;
public class canvas extends JComponent
{
//display details
private final int width=512;
private final int height=384;
//ball array
final private ArrayList<ball> ball_array;
canvas()
{
ball_array=new ArrayList<ball>();
setPreferredSize(new Dimension(width,height));
setBorder(BorderFactory.createEtchedBorder(1));
}
public void paintComponent(Graphics g)
{
super.paintComponent(g);
g.setColor(Color.BLACK);
//fill rect
g.fillRect(0,0,getWidth(),getHeight());
try
{
//draw balls from ball_array
for(int i=0;i<ball_array.size();i++)
{
ball_array.get(i).drawBall(g);
//System.out.println("Drawing ball");
}
Thread.sleep(5);//to control animation speed
}catch(InterruptedException e)
{
System.out.println("cannot control the paint thread!!");
}
repaint();//calls the paint method
}
//to add a ball
public void addBall(int size)
{
ball_array.add(new ball(size));
}
//to remove a ball
public void removeBall()
{
if(!ball_array.isEmpty())
{
ball_array.remove(ball_array.size()-1);
}
}
//return total balls from the array
public int countBall()
{
return ball_array.size();
}
//Ball inner-class
class ball
{
private int x_pos=0;
private int y_pos=0;
private int dir_x=1;
private int dir_y=1;
private int size;
ball(int size)
{
this.size=size;
}
private void calculate_direction()
{
//move the ball
x_pos=x_pos-dir_x;
y_pos=y_pos-dir_y;
//for X-direction
if(x_pos<0)
{
x_pos=0;
dir_x=-1;//incr
}
else
if(x_pos+size>getWidth())
{
dir_x=1;//decr
}
//for Y-direction
if(y_pos<0)
{
y_pos=0;
dir_y=-1;//incr
}else
if(y_pos+size>getHeight())
{
dir_y=1;//decr
}
}
public void drawBall(Graphics g)
{
calculate_direction();
g.setColor(Color.WHITE);
g.drawOval(x_pos,y_pos,size,size);
}
}
}