The Bouncing ball, explained

[Mike Gosling]

As I saw here on this forum, there are couple of posts that are dealing with the Bouncing ball program, where people are posting what they cannot figure out. I'll do the same, but I will also try to hit the core problem of this programming assignment and make the best effort to try to explain what I can't understand, since I am very new at this.

The code in question is from CS106A lectures at Stanford. Here`s the code:

import acm.program.*;
import acm.graphics.*;

public class BouncingBall extends GraphicsProgram {
	
	/** Size (diameter) of the ball */
	private static final int DIAM_BALL = 30;
	
	/** Amount Y velocity is increased each cycle as a result of gravity  */
	private static final double GRAVITY = 3;
	
	/** AnimatIon delay or pause time between ball moves */
	private static final int DELEY = 50;
	
	/** Initial X and Y location of the ball */
	private static final double X_START = DIAM_BALL / 2;
	private static final double Y_START = 100;
	
	/** X Velocity */
	private static final double X_VEL = 5;
	
	/** Amount Y velocity is reduced when it bounces  */
	private static final double BOUNCE_REDUCE = 0.9;
	
	/** Starting X and Y velocities */
	private double xVel = X_VEL;
	private double yVel = 0.00;
	
	/* private instance variable */
	private GOval ball;
	
	public void run(){
		setup(); // Simulation ends when ball goes of right-hand-end of screen //
		
		while(ball.getX() < getWidth()){
			moveBall();
			checkForCollision();
			pause(DELEY);
		} 
		
	}
	
	/** Creates and place ball */
	private void setup(){
		ball = new GOval (X_START, Y_START, DIAM_BALL, DIAM_BALL);
		ball.setFilled(true);
		add(ball);
	}
	
	/** Update and move ball */
	private void moveBall(){
		// Increase yVelocity due to gravity on each cycle 
		yVel += GRAVITY;
		ball.move(xVel, yVel);
	}
	
	/** Determine if collision with floor, update velocities and location as appropriate. */
	private void checkForCollision(){
		
		// Determine if the ball has dropped below the floor 
		if (ball.getY() > getHeight() - DIAM_BALL){
			
			// Change ball's Y velocity to now bounce upwards
			yVel = -yVel * BOUNCE_REDUCE;
			
			// Assume bounce will move ball an amount above the
			// floor equal to the amount it would have dropped
			// below the floor 
			double diff = ball.getY() - (getHeight() - DIAM_BALL);
			ball.move(0, -2*diff);
		}
	}
	
	
}

As I can see, from the while loop, the logic is to move the ball, check to see if there is collision with the bottom of the screen, if no, do the pause, in order to get animation effect and continue in this order until you hit the bottom. The moveBall() method tells me, on each iteration, increase ball`s velocity in Y direction (downwards) to get the acceleration effect due to gravity. Now, in order to move the ball, the move() method must be called upon object, that is the ball. move(dx, dy) method, by it`s definition tells: move the object dx and dy pixels from its current position.

Now comes the funky part, as the lecturer of the course mentioned above would say. The checkForCollision() method. If the condition ball.getY() > getHeight() - DIAM_BALL, is true, that means, if I understood correctly that ball is touching the bottom of the screen and the thing that should happen next is bouncing, or simply the ball needs to bounce off the bottom.

So, the process or the action of bouncing, requires the ball to change the direction of the ball, so now the yVel has the negative sign and it (ball) retains 90% of its previous speed. What I don`t understand is how the ball is actually moving upward ? If we look at the moveBall() method, I can see that the effect of moving is happening because of ball.move(xVel, yVel) + the pause(DELEY) in the while loop. But in checkForCollision() method the code defines the necessary Y velocity and its direction in this code line yVel = -yVel * BOUNCE_REDUCE, I don`t see how and where is that yVel implemented ??? I don`t understand the effect of moving upwards! How does the yVel behaves in this program since it is an instance variable ?

One more thing, what tells us how far will the ball bounce, that is how to know when to start falling down again ?  

[Henry Wong]

Miljan Puletic wrote:
So, the process or the action of bouncing, requires the ball to change the direction of the ball, so now the yVel has the negative sign and it (ball) retains 90% of its previous speed. What I don`t understand is how the ball is actually moving upward ?

Well, if the variable is a measure of downward velocity, and the expression changes the sign to negative, doesn't a negative downward velocity mean upward velocity?

Miljan Puletic wrote:
One more thing, what tells us how far will the ball bounce, that is how to know when to start falling down again ?  

Well, if the velocity is a negative downward velocity, and you are adding velocity due to gravity, doesn't that make the negative number bigger (ie. towards zero)? And soon or later, it will hit zero and positive again? meaning it will stop going up and start going downward again?

Henry