Modify the boxball class to move and accelerate. When projecting, xSpeed should range from -50 to 50 and ySpeed should range from -50 to -20.

-Create a class constant named GRAVITY and define a value for it (should be relatively small) -Modify the move method to accelerate the boxBall based on the gravity constant. Hint 1: Acceleration/deceleration is a change in ySpeed value Hint 2: ySpeed is reverse of normal physics, negative is up, positive is down -Modify the move method to update its x position based on xSpeed (similar to how y position is done) Tip: Modify the gravity constant after doing this to see how it changes the ball movement -Modify the move method to check if the ball has hit the border on the left and right of the inner box (top and bottom are already there) -Modify the move method to project the boxBall in a random direction when it stops moving horizontally.

import java.awt.*; import java.awt.geom.*; import java.util.Random;

/** * A ball that bounces inside a box. * */ public class BoxBall { private float friction = 0.8f; private Ellipse2D.Double circle; private Color color; private int diameter; private float xPosition; private float yPosition; private final Rectangle bounds; private Canvas canvas; private float xSpeed; private float ySpeed;// initial downward speed Random random = new Random(); //#1 /** * Constructor for objects of class BoxBall * * @param xPos the horizontal coordinate of the ball * @param yPos the vertical coordinate of the ball * @param xSpeed the horizontal speed of the ball * @param ySpeed the vertical speed of the ball * * @param ballDiameter the diameter (in pixels) of the ball * @param ballColor the color of the ball * @param bounds the rectangle the ball should bounce withing * @param drawingCanvas the canvas to draw this ball on */ public BoxBall(int xPos, int yPos, int xSpeed, int ySpeed, int ballDiameter, Color ballColor, Rectangle boundingRectangle, Canvas drawingCanvas) { xPosition = xPos; yPosition = yPos; this.xSpeed = xSpeed; this.ySpeed = ySpeed; color = ballColor; diameter = ballDiameter; bounds = boundingRectangle; canvas = drawingCanvas; }

/** * Draw this ball at its current position onto the canvas. **/ public void draw() { canvas.setForegroundColor(color); canvas.fillCircle((int)xPosition, (int)yPosition, diameter); }

/** * Erase this ball at its current position. **/ public void erase() { canvas.eraseCircle((int)xPosition, (int)yPosition, diameter); }

/** * Move this ball according to its position and speed and redraw. **/ public void move() { // remove from canvas at the current position erase(); // small amount of x friction to prevent it from sliding too long xSpeed *= 0.99f; // stop ball from moving in x when a very low value if (Math.abs(xSpeed) < 1.0f) { xSpeed = 0; } //#2 //#5 // compute new position yPosition += ySpeed; //#3 // check if it has hit the border if(yPosition >= (bounds.getMaxY() - diameter) && ySpeed > 0) { yPosition = (int)(bounds.getMaxY() - diameter); ySpeed = -ySpeed * friction; if(ySpeed > 0) { ySpeed = 0; } } else if(yPosition <= (bounds.getMinY()) && ySpeed < 0) { yPosition = (int)(bounds.getMinY()) + 1; ySpeed = -ySpeed * friction; if(ySpeed < 0) { ySpeed = 0; } } //#4

// draw again at new position draw(); }

/** * return the horizontal position of this ball */ public float getXPosition() { return xPosition; }

/** * return the vertical position of this ball */ public float getYPosition() { return yPosition; } /** * return true if the ball is still moving */ public boolean isMoving() { return (xSpeed != 0 || ySpeed != 0); }

}

import java.awt.*; import java.awt.geom.*;

/** * Class BouncingBall - a graphical ball that observes the effect of gravity. The ball * has the ability to move. Details of movement are determined by the ball itself. It * will fall downwards, accelerating with time due to the effect of gravity, and bounce * upward again when hitting the ground. * * This movement can be initiated by repeated calls to the "move" method. * * @author Bruce Quig * @author Michael Kolling (mik) * @author David J. Barnes * * @version 2016.02.29 */

public class BouncingBall { private static final int GRAVITY = 3; // effect of gravity

private int ballDegradation = 2; private Ellipse2D.Double circle; private Color color; private int diameter; private int xPosition; private int yPosition; private final int groundPosition; // y position of ground private Canvas canvas; private int ySpeed = 1; // initial downward speed

/** * Constructor for objects of class BouncingBall * * @param xPos the horizontal coordinate of the ball * @param yPos the vertical coordinate of the ball * @param ballDiameter the diameter (in pixels) of the ball * @param ballColor the color of the ball * @param groundPos the position of the ground (where the wall will bounce) * @param drawingCanvas the canvas to draw this ball on */ public BouncingBall(int xPos, int yPos, int ballDiameter, Color ballColor, int groundPos, Canvas drawingCanvas) { xPosition = xPos; yPosition = yPos; color = ballColor; diameter = ballDiameter; groundPosition = groundPos; canvas = drawingCanvas; }

/** * Draw this ball at its current position onto the canvas. **/ public void draw() { canvas.setForegroundColor(color); canvas.fillCircle(xPosition, yPosition, diameter); }

/** * Erase this ball at its current position. **/ public void erase() { canvas.eraseCircle(xPosition, yPosition, diameter); }

/** * Move this ball according to its position and speed and redraw. **/ public void move() { // remove from canvas at the current position erase(); // compute new position ySpeed += GRAVITY; yPosition += ySpeed; xPosition +=2;

// check if it has hit the ground if(yPosition >= (groundPosition - diameter) && ySpeed > 0) { yPosition = (int)(groundPosition - diameter); ySpeed = -ySpeed + ballDegradation; }

// draw again at new position draw(); }

/** * return the horizontal position of this ball */ public int getXPosition() { return xPosition; }

/** * return the vertical position of this ball */ public int getYPosition() { return yPosition; } }

import java.awt.*; import java.awt.geom.*; import java.util.Random;

/** * A ball that bounces inside a box. * */ public class BoxBall { private float friction = 0.8f; private Ellipse2D.Double circle; private Color color; private int diameter; private float xPosition; private float yPosition; private final Rectangle bounds; private Canvas canvas; private float xSpeed; private float ySpeed;// initial downward speed Random random = new Random(); //#1 /** * Constructor for objects of class BoxBall * * @param xPos the horizontal coordinate of the ball * @param yPos the vertical coordinate of the ball * @param xSpeed the horizontal speed of the ball * @param ySpeed the vertical speed of the ball * * @param ballDiameter the diameter (in pixels) of the ball * @param ballColor the color of the ball * @param bounds the rectangle the ball should bounce withing * @param drawingCanvas the canvas to draw this ball on */ public BoxBall(int xPos, int yPos, int xSpeed, int ySpeed, int ballDiameter, Color ballColor, Rectangle boundingRectangle, Canvas drawingCanvas) { xPosition = xPos; yPosition = yPos; this.xSpeed = xSpeed; this.ySpeed = ySpeed; color = ballColor; diameter = ballDiameter; bounds = boundingRectangle; canvas = drawingCanvas; }

/** * Draw this ball at its current position onto the canvas. **/ public void draw() { canvas.setForegroundColor(color); canvas.fillCircle((int)xPosition, (int)yPosition, diameter); }

/** * Erase this ball at its current position. **/ public void erase() { canvas.eraseCircle((int)xPosition, (int)yPosition, diameter); }

/** * Move this ball according to its position and speed and redraw. **/ public void move() { // remove from canvas at the current position erase(); // small amount of x friction to prevent it from sliding too long xSpeed *= 0.99f; // stop ball from moving in x when a very low value if (Math.abs(xSpeed) < 1.0f) { xSpeed = 0; } //#2 //#5 // compute new position yPosition += ySpeed; //#3 // check if it has hit the border if(yPosition >= (bounds.getMaxY() - diameter) && ySpeed > 0) { yPosition = (int)(bounds.getMaxY() - diameter); ySpeed = -ySpeed * friction; if(ySpeed > 0) { ySpeed = 0; } } else if(yPosition <= (bounds.getMinY()) && ySpeed < 0) { yPosition = (int)(bounds.getMinY()) + 1; ySpeed = -ySpeed * friction; if(ySpeed < 0) { ySpeed = 0; } } //#4

// draw again at new position draw(); }

/** * return the horizontal position of this ball */ public float getXPosition() { return xPosition; }

/** * return the vertical position of this ball */ public float getYPosition() { return yPosition; } /** * return true if the ball is still moving */ public boolean isMoving() { return (xSpeed != 0 || ySpeed != 0); }

}

import javax.swing.*; import java.awt.*; import java.awt.geom.*;

/** * Class Canvas - a class to allow for simple graphical * drawing on a canvas. * * @author Michael Kolling (mik) * @author Bruce Quig * * @version 2016.02.29 */

public class Canvas { private JFrame frame; private CanvasPane canvas; private Graphics2D graphic; private Color backgroundColor; private Image canvasImage;

/** * Create a Canvas with default height, width and background color * (300, 300, white). * @param title title to appear in Canvas Frame */ public Canvas(String title) { this(title, 300, 300, Color.white); }

/** * Create a Canvas with default background color (white). * @param title title to appear in Canvas Frame * @param width the desired width for the canvas * @param height the desired height for the canvas */ public Canvas(String title, int width, int height) { this(title, width, height, Color.white); }

/** * Create a Canvas. * @param title title to appear in Canvas Frame * @param width the desired width for the canvas * @param height the desired height for the canvas * @param bgClour the desired background color of the canvas */ public Canvas(String title, int width, int height, Color bgColor) { frame = new JFrame(); canvas = new CanvasPane(); frame.setContentPane(canvas); frame.setTitle(title); canvas.setPreferredSize(new Dimension(width, height)); backgroundColor = bgColor; frame.pack(); }

/** * Set the canvas visibility and brings canvas to the front of screen * when made visible. This method can also be used to bring an already * visible canvas to the front of other windows. * @param visible boolean value representing the desired visibility of * the canvas (true or false) */ public void setVisible(boolean visible) { if(graphic == null) { // first time: instantiate the offscreen image and fill it with // the background color Dimension size = canvas.getSize(); canvasImage = canvas.createImage(size.width, size.height); graphic = (Graphics2D)canvasImage.getGraphics(); graphic.setColor(backgroundColor); graphic.fillRect(0, 0, size.width, size.height); graphic.setColor(Color.black); } frame.setVisible(true); }

/** * Provide information on visibility of the Canvas. * @return true if canvas is visible, false otherwise */ public boolean isVisible() { return frame.isVisible(); }

/** * Draw the outline of a given shape onto the canvas. * @param shape the shape object to be drawn on the canvas */ public void draw(Shape shape) { graphic.draw(shape); canvas.repaint(); } /** * Fill the internal dimensions of a given shape with the current * foreground color of the canvas. * @param shape the shape object to be filled */ public void fill(Shape shape) { graphic.fill(shape); canvas.repaint(); }

/** * Fill the internal dimensions of the given circle with the current * foreground color of the canvas. */ public void fillCircle(int xPos, int yPos, int diameter) { Ellipse2D.Double circle = new Ellipse2D.Double(xPos, yPos, diameter, diameter); fill(circle); }

/** * Fill the internal dimensions of the given rectangle with the current * foreground color of the canvas. This is a convenience method. A similar * effect can be achieved with the "fill" method. */ public void fillRectangle(int xPos, int yPos, int width, int height) { fill(new Rectangle(xPos, yPos, width, height)); }

/** * Erase the whole canvas. */ public void erase() { Color original = graphic.getColor(); graphic.setColor(backgroundColor); Dimension size = canvas.getSize(); graphic.fill(new Rectangle(0, 0, size.width, size.height)); graphic.setColor(original); canvas.repaint(); }

/** * Erase the internal dimensions of the given circle. This is a * convenience method. A similar effect can be achieved with * the "erase" method. */ public void eraseCircle(int xPos, int yPos, int diameter) { Ellipse2D.Double circle = new Ellipse2D.Double(xPos, yPos, diameter, diameter); erase(circle); }

/** * Erase the internal dimensions of the given rectangle. This is a * convenience method. A similar effect can be achieved with * the "erase" method. */ public void eraseRectangle(int xPos, int yPos, int width, int height) { erase(new Rectangle(xPos, yPos, width, height)); }

/** * Erase a given shape's interior on the screen. * @param shape the shape object to be erased */ public void erase(Shape shape) { Color original = graphic.getColor(); graphic.setColor(backgroundColor); graphic.fill(shape); // erase by filling background color graphic.setColor(original); canvas.repaint(); }

/** * Erases a given shape's outline on the screen. * @param shape the shape object to be erased */ public void eraseOutline(Shape shape) { Color original = graphic.getColor(); graphic.setColor(backgroundColor); graphic.draw(shape); // erase by drawing background color graphic.setColor(original); canvas.repaint(); }

/** * Draws an image onto the canvas. * @param image the Image object to be displayed * @param x x co-ordinate for Image placement * @param y y co-ordinate for Image placement * @return returns boolean value representing whether the image was * completely loaded */ public boolean drawImage(Image image, int x, int y) { boolean result = graphic.drawImage(image, x, y, null); canvas.repaint(); return result; }

/** * Draws a String on the Canvas. * @param text the String to be displayed * @param x x co-ordinate for text placement * @param y y co-ordinate for text placement */ public void drawString(String text, int x, int y) { graphic.drawString(text, x, y); canvas.repaint(); }

/** * Erases a String on the Canvas. * @param text the String to be displayed * @param x x co-ordinate for text placement * @param y y co-ordinate for text placement */ public void eraseString(String text, int x, int y) { Color original = graphic.getColor(); graphic.setColor(backgroundColor); graphic.drawString(text, x, y); graphic.setColor(original); canvas.repaint(); }

/** * Draws a line on the Canvas. * @param x1 x co-ordinate of start of line * @param y1 y co-ordinate of start of line * @param x2 x co-ordinate of end of line * @param y2 y co-ordinate of end of line */ public void drawLine(int x1, int y1, int x2, int y2) { graphic.drawLine(x1, y1, x2, y2); canvas.repaint(); }

/** * Sets the foreground color of the Canvas. * @param newColor the new color for the foreground of the Canvas */ public void setForegroundColor(Color newColor) { graphic.setColor(newColor); }

/** * Returns the current color of the foreground. * @return the color of the foreground of the Canvas */ public Color getForegroundColor() { return graphic.getColor(); }

/** * Sets the background color of the Canvas. * @param newColor the new color for the background of the Canvas */ public void setBackgroundColor(Color newColor) { backgroundColor = newColor; graphic.setBackground(newColor); }

/** * Returns the current color of the background * @return the color of the background of the Canvas */ public Color getBackgroundColor() { return backgroundColor; }

/** * changes the current Font used on the Canvas * @param newFont new font to be used for String output */ public void setFont(Font newFont) { graphic.setFont(newFont); }

/** * Returns the current font of the canvas. * @return the font currently in use **/ public Font getFont() { return graphic.getFont(); }

/** * Sets the size of the canvas. * @param width new width * @param height new height */ public void setSize(int width, int height) { canvas.setPreferredSize(new Dimension(width, height)); Image oldImage = canvasImage; canvasImage = canvas.createImage(width, height); graphic = (Graphics2D)canvasImage.getGraphics(); graphic.drawImage(oldImage, 0, 0, null); frame.pack(); }

/** * Returns the size of the canvas. * @return The current dimension of the canvas */ public Dimension getSize() { return canvas.getSize(); }

/** * Waits for a specified number of milliseconds before finishing. * This provides an easy way to specify a small delay which can be * used when producing animations. * @param milliseconds the number */ public void wait(int milliseconds) { try { Thread.sleep(milliseconds); } catch (InterruptedException e) { // ignoring exception at the moment } }

/************************************************************************ * Inner class CanvasPane - the actual canvas component contained in the * Canvas frame. This is essentially a JPanel with added capability to * refresh the image drawn on it. */ private class CanvasPane extends JPanel { public void paint(Graphics g) { g.drawImage(canvasImage, 0, 0, null); } } }

import java.awt.*; import java.awt.geom.*; import java.util.HashSet; import java.util.Iterator; import java.util.Random;

/** * Class BallDemo - provides two short demonstrations showing how to use the * Canvas class. * * @author Michael Kolling and David J. Barnes * @version 2016.02.29 */

public class BallDemo { private Canvas myCanvas;

/** * Create a BallDemo object. Creates a fresh canvas and makes it visible. */ public BallDemo() { myCanvas = new Canvas("Ball Demo", 600, 500); myCanvas.setVisible(true); } /** * This method demonstrates some of the drawing operations that are * available on a Canvas object. */ public void drawDemo() { myCanvas.setFont(new Font("helvetica", Font.BOLD, 14)); myCanvas.setForegroundColor(Color.red);

myCanvas.drawString("We can draw text, ...", 20, 30); myCanvas.wait(1000);

myCanvas.setForegroundColor(Color.black); myCanvas.drawString("...draw lines...", 60, 60); myCanvas.wait(500); myCanvas.setForegroundColor(Color.gray); myCanvas.drawLine(200, 20, 300, 50); myCanvas.wait(500); myCanvas.setForegroundColor(Color.blue); myCanvas.drawLine(220, 100, 370, 40); myCanvas.wait(500); myCanvas.setForegroundColor(Color.green); myCanvas.drawLine(290, 10, 320, 120); myCanvas.wait(1000);

myCanvas.setForegroundColor(Color.gray); myCanvas.drawString("...and shapes!", 110, 90);

myCanvas.setForegroundColor(Color.red);

// the shape to draw and move int xPos = 10; Rectangle rect = new Rectangle(xPos, 150, 30, 20);

// move the rectangle across the screen for(int i = 0; i < 200; i ++) { myCanvas.fill(rect); myCanvas.wait(10); myCanvas.erase(rect); xPos++; rect.setLocation(xPos, 150); } // at the end of the move, draw once more so that it remains visible myCanvas.fill(rect); }

/** * Simulates bouncing balls */ public void bounce(int numberOfBalls) { int ground = 400; // position of the ground line myCanvas.setVisible(true); // draw the ground myCanvas.drawLine(50, ground, 550, ground); // create and show the balls Random random = new Random(); HashSet balls = new HashSet<>(); for(int i=0; i it = balls.iterator(); finished = true; while(it.hasNext()) { BouncingBall ball = it.next(); ball.move(); // stop once all balls has travelled a certain distance on x axis if(ball.getXPosition() < 550) { finished = false; } } } Iterator it = balls.iterator(); while(it.hasNext()) { BouncingBall ball = it.next(); ball.erase(); } } /** * Simulates bouncing balls in a box */ public void boxBounce(int numberOfBalls) { myCanvas.setVisible(true); // draw the box Rectangle box = new Rectangle(50,50,300,300); myCanvas.draw(box); // crate and show the balls Random random = new Random(); HashSet balls = new HashSet<>(); for(int i=0; i it = balls.iterator(); finished = true; while(it.hasNext()) { BoxBall ball = it.next(); ball.move(); // stop only once all balls has stopped moving if(ball.isMoving()) { finished = false; } } } Iterator it = balls.iterator(); while(it.hasNext()) { BoxBall ball = it.next(); ball.erase(); } } public void drawFrame() { int borderSize = 20; Dimension size = myCanvas.getSize(); Rectangle r = new Rectangle(borderSize, borderSize, (int) size.getWidth() - 2*borderSize, (int) size.getHeight() - 2*borderSize); myCanvas.draw(r); } }