Diff: BreakoutEngine/BreakoutEngine.cpp

Revision:

36:cb73014d3a99

Parent:

35:3a614d539a54

Child:

37:dd1538ae6534

--- a/BreakoutEngine/BreakoutEngine.cpp	Thu Apr 25 20:32:41 2019 +0000
+++ b/BreakoutEngine/BreakoutEngine.cpp	Thu Apr 25 20:50:49 2019 +0000
@@ -94,24 +94,18 @@
         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);
+                _laser1.set_posx(p_pos.x+7);
+                _laser1.set_posy(p_pos.y);
                 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);
+                _laser2.set_posx(p_pos.x+7);
+                _laser2.set_posy(p_pos.y);
                 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);
+                _laser3.set_posx(p_pos.x+7);
+                _laser3.set_posy(p_pos.y);
                 reset_index();
                 break;
         }
@@ -167,7 +161,7 @@
     check_wall_collision(pad);
     check_paddle_collisions(pad);
     check_brick_collisions(pad);
-    //check_laser_collisions(pad);
+    check_laser_collisions(pad);
     
     
 }
@@ -332,418 +326,33 @@
     _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();
+    for (it_L = listofLasers.begin(); it_L != listofLasers.end(); ++it_L){
+        for (it = listofBricks.begin(); it != listofBricks.end(); ++it){
+            if (
+                (it_L -> get_x() >= it -> get_x()) && //left
+                (it_L -> get_x() <= it -> get_x() + BRICK_WIDTH) && //right
+                (it_L -> get_y() >= it -> get_y()) && //bottom
+                (it_L -> get_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  
+                it_L -> set_posx(-100);
+                // audio feedback
+                pad.tone(1000.0,0.1);
+                if(it->hit() == true) {
+                    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();