bounce /breakout completed

//
// breakout.c
//
// Computer Science 50
// Problem Set 3
//

// standard libraries
#define _XOPEN_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

// Stanford Portable Library
#include <spl/gevents.h>
#include <spl/gobjects.h>
#include <spl/gwindow.h>

// height and width of game's window in pixels
#define HEIGHT 600
#define WIDTH 400
#define PADDLEHEIGHT 20
#define PADDLEWIDTH 100
// number of rows of bricks
#define ROWS 5

// number of columns of bricks
#define COLS 10

// radius of ball in pixels
#define RADIUS 10

// lives
#define LIVES 3

// prototypes
void initBricks(GWindow window);
GOval initBall(GWindow window);
GRect initPaddle(GWindow window);
GLabel initScoreboard(GWindow window);
void updateScoreboard(GWindow window, GLabel label, int points);
GObject detectCollision(GWindow window, GOval ball);
int lives = LIVES;
int points = 0;

int main(void)
{
    // seed pseudorandom number generator
    srand48(time(NULL));
    // instantiate window
    GWindow window = newGWindow(WIDTH, HEIGHT);
    // instantiate bricks
    initBricks(window);
    // instantiate ball, centered in middle of window
    GOval ball = initBall(window);
    // instantiate paddle, centered at bottom of window
    GRect paddle = initPaddle(window);
    // instantiate scoreboard, centered in middle of window, just above ball
    GLabel label = initScoreboard(window);

    // number of bricks initially
    int bricks = COLS * ROWS;

       double velocity = drand48();
       double velocityY = 2;

    // keep playing until game over

    while (lives >0 && points < 50)


    {


       GEvent event = getNextEvent(MOUSE_EVENT);

        if(event !=NULL)
        {
            if(getEventType(event) == MOUSE_MOVED)
            {
        double x = getX(event) - getWidth(paddle)/2;
        double y=500;
        setLocation(paddle,x,y);
        }

    }

         move(ball,velocity,velocityY);
           if (getX(ball) + getWidth(ball) >= getWidth(window))
           {
           velocity = -velocity;
           }
           else if (getY(ball) <= 0)
           {
           velocityY = - velocityY;
           }
           else if (getX(ball) <=0)
           {
           velocity = -velocity;
           }
           else if (getY(ball)+ getHeight(ball) >= getHeight(window))
           {

          lives = lives - 1;
          waitForClick();
          setLocation(ball,190,290);
          setLocation(paddle,150,500);
           }

           GObject object = detectCollision(window,ball);
           if (object == paddle)
           {
           velocityY = -velocityY;
           }

           if (object != NULL)
           {
               if (strcmp(getType(object),"GRect") == 0 && object != paddle && object != label)
               {

                 removeGWindow(window,object);
                 velocityY = -velocityY;
                 points = points+1;
                 updateScoreboard (window, label, points);
                 }
             }

           pause(10);
            }
            waitForClick();

    // game over
    closeGWindow(window);
    return 0;
}

/**
 * Initializes window with a grid of bricks.
 */
void initBricks(GWindow window)
{
    int   i, j, y;
    int x = -38;

    for( j = 0; j < COLS ;j++)
     {
     x = x+40;
     y = 40;
     GRect brick = newGRect(x,y,36,10);
     add (window, brick);
     setColor(brick,"PINK");
     setFilled(brick,true);

     for(int i = 0; i< ROWS -1 ;i++)
       {
       y = y + 12;
       GRect brick = newGRect(x,y,36,10);
       add(window,brick);

       if(i == 0)
         {
          setColor(brick,"RED");
          setFilled(brick,true);
         }

         if (i==1)
         {
         setColor(brick,"ORANGE");
         setFilled(brick,true);
         }

         if (i == 2)
         {
         setColor(brick,"YELLOW");
         setFilled(brick,true);
         }
         if(i == 3)
         {
         setColor(brick,"GREEN");
         setFilled(brick, true);
          }
         }
      }
    }



/**
 * Instantiates ball in center of window.  Returns ball.
 */
GOval initBall(GWindow window)
{
    GOval ball = newGOval(175,245,20,20);
    add(window,ball);
    setColor(ball,"black");
    setFilled(ball,true);

    return ball;
}

/**
 * Instantiates paddle in bottom-middle of window.
 */
GRect initPaddle(GWindow window)
{
    GRect paddle =newGRect(135,520,PADDLEWIDTH,PADDLEHEIGHT);
    add(window,paddle);

    setColor(paddle,"black");
    setFilled(paddle,true);

    return paddle;
 }

/**
 * Instantiates, configures, and returns label for scoreboard.
 */
GLabel initScoreboard(GWindow window)
{
    GLabel label = newGLabel (" ");
    add (window,label);

    setLocation(label,100,100);
    setFont(label,"Arial-20");
    return label;
}

/**
 * Updates scoreboard's label, keeping it centered in window.
 */
void updateScoreboard(GWindow window, GLabel label, int points)
{
    // update label
    char s[12];
    sprintf(s, "%i", points);
    setLabel(label, s);

    // center label in window
    double x = (getWidth(window) - getWidth(label)) / 2;
    double y = (getHeight(window) - getHeight(label)) / 2;
    setLocation(label, x, y);
}

/**
 * Detects whether basll has collided with some object in window
 * by checking the four corners of its bounding box (which are
 * outside the ball's GOval, and so the ball can't collide with
 * itself).  Returns object if so, else NULL.
 */
GObject detectCollision(GWindow window, GOval ball)
{
    // ball's location
    double x = getX(ball);
    double y = getY(ball);

    // for checking for collisions
    GObject object;

    // check for collision at ball's top-left corner
    object = getGObjectAt(window, x, y);
    if (object != NULL)
    {
        return object;
    }

    // check for collision at ball's top-right corner
    object = getGObjectAt(window, x + 2 * RADIUS, y);
    if (object != NULL)
    {
        return object;
    }

    // check for collision at ball's bottom-left corner
    object = getGObjectAt(window, x, y + 2 * RADIUS);
    if (object != NULL)
    {
        return object;
    }

    // check for collision at ball's bottom-right corner
    object = getGObjectAt(window, x + 2 * RADIUS, y + 2 * RADIUS);
    if (object != NULL)
    {
        return object;
    }

    // no collision
    return NULL;