File content as of revision 35:3a614d539a54:

#include "BreakoutEngine.h"


    
BreakoutEngine::BreakoutEngine()
{

}

BreakoutEngine::~BreakoutEngine()
{

}

void BreakoutEngine::init(int paddle_width,int paddle_height,int ball_size,int speed)
{
    // initialise the game parameters
    _paddle_width = paddle_width;
    _paddle_height = paddle_height;
    _ball_size = ball_size;
    _speed = speed;
    _number_left = 18;
    _index = 0;

    // y position on screen - WIDTH is defined in N5110.h
    _p1y = HEIGHT - GAP;

    // puts paddles and ball in middle
    _p1.init(_p1y,_paddle_height,_paddle_width);
    _ball.init(_ball_size,_speed);
    
    _brick11.init(3,GAP+1,BRICK_HEIGHT,BRICK_WIDTH);                              // need to figure out how to make a list of these
    _brick12.init(16,GAP+1,BRICK_HEIGHT,BRICK_WIDTH);
    _brick13.init(29,GAP+1,BRICK_HEIGHT,BRICK_WIDTH);
    _brick14.init(42,GAP+1,BRICK_HEIGHT,BRICK_WIDTH);
    _brick15.init(55,GAP+1,BRICK_HEIGHT,BRICK_WIDTH);
    _brick16.init(68,GAP+1,BRICK_HEIGHT,BRICK_WIDTH);
    
    _brick21.init(3,GAP+BRICK_HEIGHT+2,BRICK_HEIGHT,BRICK_WIDTH);                              // need to figure out how to make a list of these
    _brick22.init(16,GAP+BRICK_HEIGHT+2,BRICK_HEIGHT,BRICK_WIDTH);
    _brick23.init(29,GAP+BRICK_HEIGHT+2,BRICK_HEIGHT,BRICK_WIDTH);
    _brick24.init(42,GAP+BRICK_HEIGHT+2,BRICK_HEIGHT,BRICK_WIDTH);
    _brick25.init(55,GAP+BRICK_HEIGHT+2,BRICK_HEIGHT,BRICK_WIDTH);
    _brick26.init(68,GAP+BRICK_HEIGHT+2,BRICK_HEIGHT,BRICK_WIDTH);
    
    _brick31.init(3,GAP+1+((BRICK_HEIGHT+1)*2),BRICK_HEIGHT,BRICK_WIDTH);                              // need to figure out how to make a list of these
    _brick32.init(16,GAP+1+((BRICK_HEIGHT+1)*2),BRICK_HEIGHT,BRICK_WIDTH);
    _brick33.init(29,GAP+1+((BRICK_HEIGHT+1)*2),BRICK_HEIGHT,BRICK_WIDTH);
    _brick34.init(42,GAP+1+((BRICK_HEIGHT+1)*2),BRICK_HEIGHT,BRICK_WIDTH);
    _brick35.init(55,GAP+1+((BRICK_HEIGHT+1)*2),BRICK_HEIGHT,BRICK_WIDTH);
    _brick36.init(68,GAP+1+((BRICK_HEIGHT+1)*2),BRICK_HEIGHT,BRICK_WIDTH);
    
    listofBricks.push_back(_brick11);  //maybe be able yo iterate through and this.draw(), maybe useful if i figure out how to delete objects aswell
    listofBricks.push_back(_brick12);
    listofBricks.push_back(_brick13);
    listofBricks.push_back(_brick14);
    listofBricks.push_back(_brick15);
    listofBricks.push_back(_brick16);
    listofBricks.push_back(_brick21);
    listofBricks.push_back(_brick22);
    listofBricks.push_back(_brick23);
    listofBricks.push_back(_brick24);
    listofBricks.push_back(_brick25);
    listofBricks.push_back(_brick26);
    listofBricks.push_back(_brick31);
    listofBricks.push_back(_brick32);
    listofBricks.push_back(_brick33);
    listofBricks.push_back(_brick34);
    listofBricks.push_back(_brick35);
    listofBricks.push_back(_brick36);
    
    _laser1.init(-10);
    _laser2.init(-10);
    _laser3.init(-10);
    
    listofLasers.push_back(_laser1);
    listofLasers.push_back(_laser2);
    listofLasers.push_back(_laser3);
}

void BreakoutEngine::read_input(Gamepad &pad, bool x)
{
    _d = pad.get_direction();
    _mag = pad.get_mag();
    
    if (x == true) {
        _p1.set_tilt();
    }
    else {
        _p1.set_joy();
    }
    if (pad.check_event(Gamepad::B_PRESSED)) {  // max of 3 lasers on screen at once
        
        Vector2D p_pos = _p1.get_pos();
        switch(_index){
            case 0:
                Vector2D laser1_pos = _laser1.get_pos();
                laser1_pos.x = p_pos.x+7;
                laser1_pos.y = p_pos.y;
                _laser1.set_pos(laser1_pos);
                inc_index();
                break;
            case 1:
                Vector2D laser2_pos = _laser2.get_pos();
                laser2_pos.x = p_pos.x+7;
                laser2_pos.y = p_pos.y;
                _laser2.set_pos(laser2_pos);
                inc_index();
                break;
            case 2:
                Vector2D laser3_pos = _laser3.get_pos();
                laser3_pos.x = p_pos.x+7;
                laser3_pos.y = p_pos.y;
                _laser3.set_pos(laser3_pos);
                reset_index();
                break;
        }
    }
}

void BreakoutEngine::inc_index() {
    _index ++;
}

void BreakoutEngine::reset_index() {
    _index = 0;
}

void BreakoutEngine::draw(N5110 &lcd)
{
    // draw the elements in the LCD buffer
    // pitch
    lcd.drawRect(0,0,WIDTH,HEIGHT,FILL_TRANSPARENT);
    //score
    //print_scores(lcd);
    // paddles
    _p1.draw(lcd);
    // ball
    _ball.draw(lcd);
    
    //print_scores(lcd);
    
    for (it = listofBricks.begin(); it != listofBricks.end(); ++it){
        it->draw(lcd);
    }
    for (it_L = listofLasers.begin(); it_L != listofLasers.end(); ++it_L){
        it_L->draw(lcd);
    }

}


void BreakoutEngine::update(Gamepad &pad)
{
    check_goal(pad);
    // important to update paddles and ball before checking collisions so can
    // correct for it before updating the display
    _p1.update(_d,_mag);
    _ball.update();
    
    for (it_L = listofLasers.begin(); it_L != listofLasers.end(); ++it_L){
        it_L->update();
    }
    
    lives_leds(pad);
    
    check_wall_collision(pad);
    check_paddle_collisions(pad);
    check_brick_collisions(pad);
    //check_laser_collisions(pad);
    
    
}

void BreakoutEngine::lives_leds(Gamepad &pad)
{
    if (_p1.get_lives() == 0) {
        pad.leds_off();
    }
    
    else if (_p1.get_lives() == 1) {
        //turn leftmost led on
        pad.leds_off();
        pad.led(1,1);
    }
    
    else if (_p1.get_lives() == 2) {
        //turn leftmost led on
        pad.leds_off();
        pad.led(1,1);
        pad.led(2,1);
    }
    
    else if (_p1.get_lives() == 3) {
        //turn leftmost led on
        pad.leds_off();
        pad.led(1,1);
        pad.led(2,1);
        pad.led(3,1);
    }

    else if (_p1.get_lives() == 4) {
        pad.leds_on();
        pad.led(5,0);
        pad.led(6,0);
    }
    
    else if (_p1.get_lives() == 5) {
        pad.leds_on();
        pad.led(6,0);
    }
    
    else if (_p1.get_lives() == 6) {
        pad.leds_on();
    }
}

int BreakoutEngine::get_lives() {
    return _p1.get_lives();
}

void BreakoutEngine::check_wall_collision(Gamepad &pad)
{
    // read current ball attributes
    Vector2D ball_pos = _ball.get_pos();
    Vector2D ball_velocity = _ball.get_velocity();

    if (ball_pos.y <= 1) {  //  1 due to 1 pixel boundary
        ball_pos.y = 1;  // bounce off ceiling without going off screen
        ball_velocity.y = -ball_velocity.y;
        // audio feedback
        pad.tone(750.0,0.1);
    }
    
    else if (ball_pos.x <= 1) {  //  1 due to 1 pixel boundary
        ball_pos.x = 1;  // bounce off ceiling without going off screen
        ball_velocity.x = -ball_velocity.x;
        // audio feedback
        pad.tone(750.0,0.1);
    }
        
    // check if hit bottom wall
    else if (ball_pos.x + _ball_size >= (WIDTH-1) ) { // bottom pixel is 47
        // hit bottom
        ball_pos.x = (WIDTH-1) - _ball_size;  // stops ball going off screen
        ball_velocity.x = -ball_velocity.x;
        // audio feedback
        pad.tone(750.0,0.1);
    }

    // update ball parameters
    _ball.set_velocity(ball_velocity);
    _ball.set_pos(ball_pos);
    
}

void BreakoutEngine::check_paddle_collisions(Gamepad &pad)
{
    // read current ball attributes
    Vector2D ball_pos = _ball.get_pos();
    Vector2D ball_velocity = _ball.get_velocity();

    // check p1 first
    Vector2D p1_pos = _p1.get_pos();

    // see if ball has hit the paddle by checking for overlaps
    if (
        (ball_pos.x >= p1_pos.x) && //left 
        (ball_pos.x <= p1_pos.x + _paddle_width) && //right
        (ball_pos.y >= _p1y) && //bottom
        (ball_pos.y <= _p1y + _paddle_height)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        pad.tone(1000.0,0.1);
        ball_pos.y = _p1y + _paddle_height - 1;
        ball_velocity.y = -ball_velocity.y;
    
//        if (ball_pos.x == p1_pos.x + PADDLE_WIDTH/2) {     // check ballxpos in relation to paddle xpos. translate the distance from the centre to an angle between 30 and 60 degrees in that direction
//            ball_pos.y = _p1y + _paddle_height - 1;
//            ball_velocity.y = -ball_velocity.y;
//        }
//        else if (ball_pos.x <= p1_pos.x + PADDLE_WIDTH/2) {
//            float ang = 40*(((p1_pos.x + PADDLE_WIDTH/2)-ball_pos.x)/(PADDLE_WIDTH/2 - p1_pos.x)) + 30;  //converts the distance from the centre to an angle between 30 and 60
//            if (ball_velocity.x > 0) {
//                ball_velocity.x = -ball_velocity.x;
//            }
 //           ball_pos.y = _p1y + _paddle_heigh - 1;
 //           ball_velocity.y = -tan(ang);
 //       }
 //       else if (ball_pos.x >= p1_pos.x + PADDLE_WIDTH/2) {
 //           float ang = 40*(((p1_pos.x + PADDLE_WIDTH/2)-ball_pos.x)/(PADDLE_WIDTH/2 - p1_pos.x)) + 30;  //converts the distance from the centre to an angle between 30 and 60
 //           if (ball_velocity.x < 0) {
 //               ball_velocity.x = -ball_velocity.x;
 //           }
 //           ball_pos.y = _p1y + _paddle_height - 1;
 //           ball_velocity.y = -tan(ang);
 //       }
    }

    // write new attributes
    _ball.set_velocity(ball_velocity);
    _ball.set_pos(ball_pos);
}

void BreakoutEngine::check_brick_collisions(Gamepad &pad)
{
    // read current ball attributes
    Vector2D ball_pos = _ball.get_pos();
    Vector2D ball_velocity = _ball.get_velocity();
    
    for (it = listofBricks.begin(); it != listofBricks.end(); ++it){
        if (
            (ball_pos.x >= it -> get_x()) && //left
            (ball_pos.x <= it -> get_x() + BRICK_WIDTH) && //right
            (ball_pos.y >= it -> get_y()) && //bottom
            (ball_pos.y <= it -> get_y() + BRICK_HEIGHT)  //top
        ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
            // if it has, fix position and reflect x velocity  
            ball_pos.y = it -> get_y() + BRICK_HEIGHT;
            ball_velocity.y = -ball_velocity.y;
            // audio feedback
            pad.tone(1000.0,0.1);
            it -> hit();
            it -> hit();
            //delete _brick11;
            it -> set_posx(-100);
            it -> set_posy(-100);
            one_less();
        }
    }
    // write new attributes
    _ball.set_velocity(ball_velocity);
    _ball.set_pos(ball_pos);
}
/*
void BreakoutEngine::check_laser_collisions(Gamepad &pad)
{
    // read current ball attributes
    Vector2D laser1_pos = _laser1.get_pos();
    Vector2D laser2_pos = _laser2.get_pos();
    Vector2D laser3_pos = _laser3.get_pos();
    // check p1 first
    
    for (it = listofBricks.begin(); it != listofBricks.end(); ++it){
        if (
            (ball_pos.x >= it -> get_x()) && //left
            (ball_pos.x <= it -> get_x() + BRICK_WIDTH) && //right
            (ball_pos.y >= it -> get_y()) && //bottom
            (ball_pos.y <= it -> get_y() + BRICK_HEIGHT)  //top
        ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
            // if it has, fix position and reflect x velocity  
            ball_pos.y = it -> get_y() + BRICK_HEIGHT;
            ball_velocity.y = -ball_velocity.y;
            // audio feedback
            pad.tone(1000.0,0.1);
            it -> hit();
            it -> hit();
            //delete _brick11;
            it -> set_posx(-100);
            it -> set_posy(-100);
            one_less();
        }
    }
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick11_pos.x) && //left
        (laser1_pos.x <= _brick11_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick11_pos.y) && //bottom
        (laser1_pos.y <= _brick11_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick11.hit() == true) {
            _brick11_pos.x = -100;
            _brick11_pos.y = -100;
            _brick11.set_pos(_brick11_pos);
            one_less();
        //}
        //delete _brick11;
        
    }
    // check p1 first
    Vector2D _brick12_pos = _brick12.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick12_pos.x) && //left
        (laser1_pos.x <= _brick12_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick12_pos.y) && //bottom
        (laser1_pos.y <= _brick12_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick12.hit() == true) {
            _brick12_pos.x = -100;
            _brick12_pos.y = -100;
            _brick12.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick13_pos = _brick13.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick13_pos.x) && //left
        (laser1_pos.x <= _brick13_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick13_pos.y) && //bottom
        (laser1_pos.y <= _brick13_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick13.hit() == true) {
            _brick13_pos.x = -100;
            _brick13_pos.y = -100;
            _brick13.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick14_pos = _brick14.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick14_pos.x) && //left
        (laser1_pos.x <= _brick14_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick14_pos.y) && //bottom
        (laser1_pos.y <= _brick14_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick14.hit() == true) {
            _brick14_pos.x = -100;
            _brick14_pos.y = -100;
            _brick14.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick15_pos = _brick15.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick15_pos.x) && //left
        (laser1_pos.x <= _brick15_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick15_pos.y) && //bottom
        (laser1_pos.y <= _brick15_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick15.hit() == true) {
            _brick15_pos.x = -100;
            _brick15_pos.y = -100;
            _brick15.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick16_pos = _brick16.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick16_pos.x) && //left
        (laser1_pos.x <= _brick16_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick16_pos.y) && //bottom
        (laser1_pos.y <= _brick16_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick16.hit() == true) {
            _brick16_pos.x = -100;
            _brick16_pos.y = -100;
            _brick16.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick21_pos = _brick21.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick21_pos.x) && //left
        (laser1_pos.x <= _brick21_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick21_pos.y) && //bottom
        (laser1_pos.y <= _brick21_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick21.hit() == true) {
            _brick21_pos.x = -100;
            _brick21_pos.y = -100;
            _brick21.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick22_pos = _brick22.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick22_pos.x) && //left
        (laser1_pos.x <= _brick22_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick22_pos.y) && //bottom
        (laser1_pos.y <= _brick22_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick22.hit() == true) {
            _brick22_pos.x = -100;
            _brick22_pos.y = -100;
            _brick22.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick23_pos = _brick23.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick23_pos.x) && //left
        (laser1_pos.x <= _brick23_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick23_pos.y) && //bottom
        (laser1_pos.y <= _brick23_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick23.hit() == true) {
            _brick23_pos.x = -100;
            _brick23_pos.y = -100;
            _brick23.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick24_pos = _brick24.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick24_pos.x) && //left
        (laser1_pos.x <= _brick24_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick24_pos.y) && //bottom
        (laser1_pos.y <= _brick24_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick24.hit() == true) {
            _brick24_pos.x = -100;
            _brick24_pos.y = -100;
            _brick24.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick25_pos = _brick25.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick25_pos.x) && //left
        (laser1_pos.x <= _brick25_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick25_pos.y) && //bottom
        (laser1_pos.y <= _brick25_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick25.hit() == true) {
            _brick25_pos.x = -100;
            _brick25_pos.y = -100;
            _brick25.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick26_pos = _brick26.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick26_pos.x) && //left
        (laser1_pos.x <= _brick26_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick26_pos.y) && //bottom
        (laser1_pos.y <= _brick26_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick26.hit() == true) {
            _brick26_pos.x = -100;
            _brick26_pos.y = -100;
            _brick26.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick31_pos = _brick31.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick31_pos.x) && //left
        (laser1_pos.x <= _brick31_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick31_pos.y) && //bottom
        (laser1_pos.y <= _brick31_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick31.hit() == true) {
            _brick31_pos.x = -100;
            _brick31_pos.y = -100;
            _brick31.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick32_pos = _brick32.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick32_pos.x) && //left
        (laser1_pos.x <= _brick32_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick32_pos.y) && //bottom
        (laser1_pos.y <= _brick32_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick32.hit() == true) {
            _brick32_pos.x = -100;
            _brick32_pos.y = -100;
            _brick32.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick33_pos = _brick33.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick33_pos.x) && //left
        (laser1_pos.x <= _brick33_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick33_pos.y) && //bottom
        (laser1_pos.y <= _brick33_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick33.hit() == true) {
            _brick33_pos.x = -100;
            _brick33_pos.y = -100;
            _brick33.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick34_pos = _brick34.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick34_pos.x) && //left
        (laser1_pos.x <= _brick34_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick34_pos.y) && //bottom
        (laser1_pos.y <= _brick34_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick34.hit() == true) {
            _brick34_pos.x = -100;
            _brick34_pos.y = -100;
            _brick34.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick35_pos = _brick35.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick35_pos.x) && //left
        (laser1_pos.x <= _brick35_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick35_pos.y) && //bottom
        (laser1_pos.y <= _brick35_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick35.hit() == true) {
            _brick35_pos.x = -100;
            _brick35_pos.y = -100;
            _brick35.set_pos(_brick11_pos);
            one_less();
        //}
    }
    // check p1 first
    Vector2D _brick36_pos = _brick36.get_pos();
    
    // see if ball has hit the paddle by checking for overlaps
    if (
        (laser1_pos.x >= _brick36_pos.x) && //left
        (laser1_pos.x <= _brick36_pos.x + BRICK_WIDTH) && //right
        (laser1_pos.y >= _brick36_pos.y) && //bottom
        (laser1_pos.y <= _brick36_pos.y + BRICK_HEIGHT)  //top
    ) {    // edit this so that if it hits the middle, reflect, else change angle depending on how far off centre (add angle to ball)
        // if it has, fix position and reflect x velocity  
        laser1_pos.x = -10;
        // audio feedback
        pad.tone(1000.0,0.1);
        //if(_brick36.hit() == true) {
            _brick36_pos.x = -100;
            _brick36_pos.y = -100;
            _brick36.set_pos(_brick11_pos);
            one_less();
        //}
    }

    // write new attributes
    _laser1.set_pos(laser1_pos);
}
*/
bool BreakoutEngine::check_goal(Gamepad &pad)
{
    Vector2D ball_pos = _ball.get_pos();
    // P1 has scored
    if (ball_pos.y > HEIGHT) {
        _p1.lose_life();
        //lose_screen(); // go to loss screen then initialise again
        
        _ball.init(_ball_size,_speed);
        pad.tone(1500.0,0.5);
        return true;
    }
    else {
        return false;
    }
}



void BreakoutEngine::print_scores(N5110 &lcd) //maybe add to oneless
{
    // get scores from paddles
    int p1_score = _p1.get_lives();

    // print to LCD i
    char buffer1[14];
    sprintf(buffer1,"%2d",p1_score);
    lcd.printString(buffer1,WIDTH/2 -8,4);  // font is 8 wide, so leave 4 pixel gape from middle assuming two digits
}

int BreakoutEngine::get_num_left(){
    return _number_left;
}
void BreakoutEngine::one_less() {
    _number_left -= 1;
}