pset4

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

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

// Stanford Portable Library
#include "gevents.h"
#include "gobjects.h"
#include "gwindow.h"

// height and width of game's window in pixels
#define HEIGHT 600
#define WIDTH 400

// size of the paddle
#define xp 170
#define yp 540
#define wp 60
#define hp 10

// number of rows of bricks
#define ROWS 5

// number of columns of bricks
#define COLS 10

// dimension - bricks
#define xb 36
#define yb 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 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;

    // number of lives initially
    int lives = LIVES;

    // number of points initially
    int points = 0;

    // keep playing until game over
     double xvelocity = 3.0 ;
     double yvelocity = 3.0 ;
      waitForClick();
    while (lives > 0 && bricks > 0)
    {

        // TODO
        GEvent event = getNextEvent(MOUSE_EVENT);

        // if we heard one
        if (event != NULL)
        {
            // if the event was movement
            if (getEventType(event) == MOUSE_MOVED)
            {
                // ensure circle follows top cursor
                double x = getX(event);
                if(x > (getWidth(window) - wp))
                setLocation(paddle , (getWidth(window) - wp) , yp);
                else
                setLocation(paddle, x, yp);


            }
        }

     move(ball , xvelocity ,yvelocity);




       if (getX(ball) + getWidth(ball) >= getWidth(window))
        xvelocity = -xvelocity;
       else if (getX(ball) <= 0)
        xvelocity = -xvelocity;


      else if(getY(ball) <= 0)
       yvelocity = -yvelocity ;

       updateScoreboard(window, label, points);

      GObject object = detectCollision(window , ball);
            if (object != NULL)
        {
            // If the ball hits the paddle.
            if (object == paddle)
            {
                yvelocity = -yvelocity;
            }

            // If the ball hits a block. Remove block, add a point, decrement count and bounce.
            else if (strcmp(getType(object), "GRect") == 0)
            {
                removeGWindow(window, object);
                yvelocity = -yvelocity;
                points++;
                bricks--;
            }
        }



      if(getY(ball) + getHeight(ball) >= getHeight(window) )
      {
       lives-- ;
       setLocation(ball , 190 , 290 );
       setLocation(paddle , xp ,yp );
       pause(1000);
      }
      pause(10);
    }

    // wait for click before exiting
    waitForClick();

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

/**
 * Initializes window with a grid of bricks.
 */
void initBricks(GWindow window)
{
    //TODO
    int ysb = 3 ;
    int xsb = 5 ;
    for (int i = 0 ; i < ROWS ; i++ )
    {
     for (int j = 0 ; j < COLS ; j++ )
     {
      GRect brick = newGRect(xsb , ysb , xb , yb);
      if(i == 0)
      setColor(brick , "RED" );
      if(i == 1)
      setColor(brick , "ORANGE");
      if(i == 2)
      setColor(brick ,"YELLOW" );
      if(i == 3)
      setColor(brick ,"GREEN" );
      if(i == 4)
      setColor(brick , "BLUE");

      setFilled(brick , true);
      add(window , brick );
      xsb = xsb + 39 ;
      printf("\n");
     }
     xsb = 5 ;
     ysb = ysb + 15 ;
    }

}

/**
 * Instantiates ball in center of window.  Returns ball.
 */
GOval initBall(GWindow window)
{
    // TODO
    GOval ball = newGOval( 190  , 290  , 20 , 20 );
    setColor(ball , "BLACK");
    setFilled(ball , true);
    add(window , ball);
    return ball;
}

/**
 * Instantiates paddle in bottom-middle of window.
 */
GRect initPaddle(GWindow window)
{
    // TODO

    GRect paddle = newGRect(xp , yp , wp , hp );
    setFilled(paddle, true);
    setColor(paddle, "RED");

    add(window, paddle);
    return paddle;
}

/**
 * Instantiates, configures, and returns label for scoreboard.
 */
GLabel initScoreboard(GWindow window)
{
    // TODO
    GLabel points = newGLabel("0");
    setLocation(points , 200 ,300 );
    setFilled(points , true);
    setColor(points , "GREY");

    add(window ,points);
    return points ;
}

/**
 * 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 ball 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;
}