Academic Integrity: tutoring, explanations, and feedback — we don’t complete graded work or submit on a student’s behalf.

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);

        }

    }

}