Snake vs Block Game to be run upon K64F.

Dependencies:   mbed

Revision:
24:1c118b071430
Parent:
23:592345a70329
Child:
25:e827f1a8fadc
--- a/SnakevsBlock/SnakevsBlock.cpp	Wed Apr 10 09:00:45 2019 +0000
+++ b/SnakevsBlock/SnakevsBlock.cpp	Wed Apr 10 10:59:15 2019 +0000
@@ -459,219 +459,149 @@
     {
         //Obtains all required coordinates.
         Vector2D b_pos = _b.get_pos();
-        snake_posx[0] = _s.get_pos(length).x;
-        snake_posy[0] = _s.get_pos(length).y;
-        snake_posx[1] = _s.get_pos_before1(length).x;
-        snake_posy[1] = _s.get_pos_before1(length).y;
-        snake_posx[2] = _s.get_pos_before2(length).x;
-        snake_posy[2] = _s.get_pos_before2(length).y;
-        snake_posx[3] = _s.get_pos_before3(length).x;
-        snake_posy[3] = _s.get_pos_before3(length).y;
-        snake_posx[4] = _s.get_pos_before4(length).x;
-        snake_posy[4] = _s.get_pos_before4(length).y;
-        snake_posx[5] = _s.get_pos_before5(length).x;
-        snake_posy[5] = _s.get_pos_before5(length).y;
-        snake_posx[6] = _s.get_pos_before6(length).x;
-        snake_posy[6] = _s.get_pos_before6(length).y;
-        snake_posx[7] = _s.get_pos_before7(length).x;
-        snake_posy[7] = _s.get_pos_before7(length).y;
-        snake_posx[8] = _s.get_pos_before8(length).x;
-        snake_posy[8] = _s.get_pos_before8(length).y;
-        snake_posx[9] = _s.get_pos_before9(length).x;
-        snake_posy[9] = _s.get_pos_before9(length).y;
-        snake_posx[10] = _s.get_pos_before10(length).x;
-        snake_posy[10] = _s.get_pos_before10(length).y;
-        snake_posx[11] = _s.get_pos_before11(length).x;
-        snake_posy[11] = _s.get_pos_before11(length).y;
-        snake_posx[12] = _s.get_pos_before12(length).x;
-        snake_posy[12] = _s.get_pos_before12(length).y;
-        snake_posx[13] = _s.get_pos_before13(length).x;
-        snake_posy[13] = _s.get_pos_before13(length).y;
-        snake_posx[14] = _s.get_pos_before14(length).x;
-        snake_posy[14] = _s.get_pos_before14(length).y;
-        Vector2D snake_pos = _s.get_pos(length);
-        Vector2D snake_posb1 = _s.get_pos_before1(length);
-        Vector2D snake_posb2 = _s.get_pos_before2(length);
-        Vector2D snake_posb3 = _s.get_pos_before3(length);
-        Vector2D snake_posb4 = _s.get_pos_before4(length);
-        Vector2D snake_posb5 = _s.get_pos_before5(length);
-        Vector2D snake_posb6 = _s.get_pos_before6(length);
-        Vector2D snake_posb7 = _s.get_pos_before7(length);
-        Vector2D snake_posb8 = _s.get_pos_before8(length);
-        Vector2D snake_posb9 = _s.get_pos_before9(length);
-        Vector2D snake_posb10 = _s.get_pos_before10(length);
-        Vector2D snake_posb11 = _s.get_pos_before11(length);
-        Vector2D snake_posb12 = _s.get_pos_before12(length);
-        Vector2D snake_posb13 = _s.get_pos_before13(length);
-        Vector2D snake_posb14 = _s.get_pos_before14(length);
+        snake_pos[0] = _s.get_pos(length);
+        snake_pos[1] = _s.get_pos_before1(length);
+        snake_pos[2] = _s.get_pos_before2(length);
+        snake_pos[3] = _s.get_pos_before3(length);
+        snake_pos[4] = _s.get_pos_before4(length);
+        snake_pos[5] = _s.get_pos_before5(length);
+        snake_pos[6] = _s.get_pos_before6(length);
+        snake_pos[7] = _s.get_pos_before7(length);
+        snake_pos[8] = _s.get_pos_before8(length);
+        snake_pos[9] = _s.get_pos_before9(length);
+        snake_pos[10] = _s.get_pos_before10(length);
+        snake_pos[11] = _s.get_pos_before11(length);
+        snake_pos[12] = _s.get_pos_before12(length);
+        snake_pos[13] = _s.get_pos_before13(length);
+        snake_pos[14] = _s.get_pos_before14(length);
         
         //If statements check if the snake sprite has collided with any
         //of the blocks' sides and then stop the snake moving in x axis
         
-            speed = 1;
-            for(int i=0; i<=14; i++)  {
-                b[i] = 1;
-            }
+        speed = 1;
+        for(int i=0; i<=14; i++)  {
+            b[i] = 1;
+        }
         
     //For West
     for(int i=0; i<=14; i++)  {
         if (
-            ((((snake_posy[i] == b_pos.y + 1) ||
-            (snake_posy[i] == b_pos.y + 1) ||
-            (snake_posy[i] == b_pos.y + 2) ||
-            (snake_posy[i] == b_pos.y + 3) ||
-            (snake_posy[i] == b_pos.y + 4) ||
-            (snake_posy[i] == b_pos.y + 5) ||
-            (snake_posy[i] == b_pos.y + 6) ||
-            (snake_posy[i] == b_pos.y + 7) ||
-            (snake_posy[i] == b_pos.y + 8) ||
-            (snake_posy[i] == b_pos.y + 9) ||
-            (snake_posy[i] == b_pos.y + 10) ||
-            (snake_posy[i] + 1 == b_pos.y) ||
-            (snake_posy[i] + 1 == b_pos.y + 1) ||
-            (snake_posy[i] + 1 == b_pos.y + 2) ||
-            (snake_posy[i] + 1 == b_pos.y + 3) ||
-            (snake_posy[i] + 1 == b_pos.y + 4) ||
-            (snake_posy[i] + 1 == b_pos.y + 5) ||
-            (snake_posy[i] + 1 == b_pos.y + 6) ||
-            (snake_posy[i] + 1 == b_pos.y + 7) ||
-            (snake_posy[i] + 1 == b_pos.y + 8) ||
-            (snake_posy[i] + 1 == b_pos.y + 9) ||
-            (snake_posy[i] + 1 == b_pos.y + 10) ||
-            (snake_posy[i] + 2 == b_pos.y) ||
-            (snake_posy[i] + 2 == b_pos.y + 1) ||
-            (snake_posy[i] + 2 == b_pos.y + 2) ||
-            (snake_posy[i] + 2 == b_pos.y + 3) ||
-            (snake_posy[i] + 2 == b_pos.y + 4) ||
-            (snake_posy[i] + 2 == b_pos.y + 5) ||
-            (snake_posy[i] + 2 == b_pos.y + 6) ||
-            (snake_posy[i] + 2 == b_pos.y + 7) ||
-            (snake_posy[i] + 2 == b_pos.y + 8) ||
-            (snake_posy[i] + 2 == b_pos.y + 9) ||
-            (snake_posy[i] + 2 == b_pos.y + 10)) &&
-            ((snake_posx[i] == b_pos.x + 4) ||  //W
-            (snake_posx[i] == b_pos.x + 36) ||  //W
-            (snake_posx[i] == b_pos.x + 68) ||  //W
-            (snake_posx[i] + 1 == b_pos.x + 4) ||  //W
-            (snake_posx[i] + 1 == b_pos.x + 36) ||  //W
-            (snake_posx[i] + 1 == b_pos.x + 68) ||  //W
-            (snake_posx[i] + 2 == b_pos.x + 4) ||  //W
-            (snake_posx[i] + 2 == b_pos.x + 36) ||  //W
-            (snake_posx[i] + 2 == b_pos.x + 68) ||  //W
-            (snake_posx[i] == b_pos.x + 20) ||  //W
-            (snake_posx[i] == b_pos.x + 52) ||  //W
-            (snake_posx[i] == b_pos.x + 84) ||  //W
-            (snake_posx[i] + 1 == b_pos.x + 20) ||  //W
-            (snake_posx[i] + 1 == b_pos.x + 52) ||  //W
-            (snake_posx[i] + 1 == b_pos.x + 84) ||  //W
-            (snake_posx[i] + 2 == b_pos.x + 20) ||  //W
-            (snake_posx[i] + 2 == b_pos.x + 52) ||  //W
-            (snake_posx[i] + 2 == b_pos.x + 84)))&&(d != E)&&(length > i)) //W
+            ((((snake_pos[i].y == b_pos.y + 1) ||
+            (snake_pos[i].y == b_pos.y + 1) ||
+            (snake_pos[i].y == b_pos.y + 2) ||
+            (snake_pos[i].y == b_pos.y + 3) ||
+            (snake_pos[i].y == b_pos.y + 4) ||
+            (snake_pos[i].y == b_pos.y + 5) ||
+            (snake_pos[i].y == b_pos.y + 6) ||
+            (snake_pos[i].y == b_pos.y + 7) ||
+            (snake_pos[i].y == b_pos.y + 8) ||
+            (snake_pos[i].y == b_pos.y + 9) ||
+            (snake_pos[i].y == b_pos.y + 10) ||
+            (snake_pos[i].y + 1 == b_pos.y) ||
+            (snake_pos[i].y + 1 == b_pos.y + 1) ||
+            (snake_pos[i].y + 1 == b_pos.y + 2) ||
+            (snake_pos[i].y + 1 == b_pos.y + 3) ||
+            (snake_pos[i].y + 1 == b_pos.y + 4) ||
+            (snake_pos[i].y + 1 == b_pos.y + 5) ||
+            (snake_pos[i].y + 1 == b_pos.y + 6) ||
+            (snake_pos[i].y + 1 == b_pos.y + 7) ||
+            (snake_pos[i].y + 1 == b_pos.y + 8) ||
+            (snake_pos[i].y + 1 == b_pos.y + 9) ||
+            (snake_pos[i].y + 1 == b_pos.y + 10) ||
+            (snake_pos[i].y + 2 == b_pos.y) ||
+            (snake_pos[i].y + 2 == b_pos.y + 1) ||
+            (snake_pos[i].y + 2 == b_pos.y + 2) ||
+            (snake_pos[i].y + 2 == b_pos.y + 3) ||
+            (snake_pos[i].y + 2 == b_pos.y + 4) ||
+            (snake_pos[i].y + 2 == b_pos.y + 5) ||
+            (snake_pos[i].y + 2 == b_pos.y + 6) ||
+            (snake_pos[i].y + 2 == b_pos.y + 7) ||
+            (snake_pos[i].y + 2 == b_pos.y + 8) ||
+            (snake_pos[i].y + 2 == b_pos.y + 9) ||
+            (snake_pos[i].y + 2 == b_pos.y + 10)) &&
+            ((snake_pos[i].x == b_pos.x + 4) ||  //W
+            (snake_pos[i].x == b_pos.x + 36) ||  //W
+            (snake_pos[i].x == b_pos.x + 68) ||  //W
+            (snake_pos[i].x + 1 == b_pos.x + 4) ||  //W
+            (snake_pos[i].x + 1 == b_pos.x + 36) ||  //W
+            (snake_pos[i].x + 1 == b_pos.x + 68) ||  //W
+            (snake_pos[i].x + 2 == b_pos.x + 4) ||  //W
+            (snake_pos[i].x + 2 == b_pos.x + 36) ||  //W
+            (snake_pos[i].x + 2 == b_pos.x + 68) ||  //W
+            (snake_pos[i].x == b_pos.x + 20) ||  //W
+            (snake_pos[i].x == b_pos.x + 52) ||  //W
+            (snake_pos[i].x == b_pos.x + 84) ||  //W
+            (snake_pos[i].x + 1 == b_pos.x + 20) ||  //W
+            (snake_pos[i].x + 1 == b_pos.x + 52) ||  //W
+            (snake_pos[i].x + 1 == b_pos.x + 84) ||  //W
+            (snake_pos[i].x + 2 == b_pos.x + 20) ||  //W
+            (snake_pos[i].x + 2 == b_pos.x + 52) ||  //W
+            (snake_pos[i].x + 2 == b_pos.x + 84)))&&(d != E)&&(length > i)) //W
             ) {
-            //add some code that it doesn't move
-            if(length == 1 + i)  {
-                b[0] = 0;
-            }
-            if(length == 2 + i)  {
-                b[1] = 0;
-            }
-            if(length== 3 + i)  {
-                b[2] = 0;
-            }
-            if(length== 4 + i)  {
-                b[3] = 0;
-            }
-            if(length== 5 + i)  {
-                b[4] = 0;
-            }
-            if(length== 6 + i)  {
-                b[5] = 0;
-            }
-            if(length== 7 + i)  {
-                b[6] = 0;
-            }
-            if(length== 8 + i)  {
-                b[7] = 0;
-            }
-            if(length== 9 + i)  {
-                b[8] = 0;
-            }
-            if(length== 10 + i)  {
-                b[9] = 0;
-            }
-            if(length== 11 + i)  {
-                b[10] = 0;
-            }
-            if(length== 12 + i)  {
-                b[11] = 0;
-            }
-            if(length== 13 + i)  {
-                b[12] = 0;
-            }
-            if(length == 14 + i)  {
-                b[13] = 0;
-            }
-            if(length== 15 + i)  {
-                b[14] = 0;
+            //code makes sure that the colliding part doesn't move in x axis.
+            for(int snake_beed_num=0; snake_beed_num<=15; snake_beed_num++)  {
+                if(length == snake_beed_num + i)  {
+                    b[snake_beed_num - 1] = 0;
+                }
             }
         }
         
          //for East
-            if (
-                ((((snake_posy[i] == b_pos.y + 1) ||
-                (snake_posy[i] == b_pos.y + 1) ||
-                (snake_posy[i] == b_pos.y + 2) ||
-                (snake_posy[i] == b_pos.y + 3) ||
-                (snake_posy[i] == b_pos.y + 4) ||
-                (snake_posy[i] == b_pos.y + 5) ||
-                (snake_posy[i] == b_pos.y + 6) ||
-                (snake_posy[i] == b_pos.y + 7) ||
-                (snake_posy[i] == b_pos.y + 8) ||
-                (snake_posy[i] == b_pos.y + 9) ||
-                (snake_posy[i] == b_pos.y + 10) ||
-                (snake_posy[i] + 1 == b_pos.y) ||
-                (snake_posy[i] + 1 == b_pos.y + 1) ||
-                (snake_posy[i] + 1 == b_pos.y + 2) ||
-                (snake_posy[i] + 1 == b_pos.y + 3) ||
-                (snake_posy[i] + 1 == b_pos.y + 4) ||
-                (snake_posy[i] + 1 == b_pos.y + 5) ||
-                (snake_posy[i] + 1 == b_pos.y + 6) ||
-                (snake_posy[i] + 1 == b_pos.y + 7) ||
-                (snake_posy[i] + 1 == b_pos.y + 8) ||
-                (snake_posy[i] + 1 == b_pos.y + 9) ||
-                (snake_posy[i] + 1 == b_pos.y + 10) ||
-                (snake_posy[i] + 2 == b_pos.y) ||
-                (snake_posy[i] + 2 == b_pos.y + 1) ||
-                (snake_posy[i] + 2 == b_pos.y + 2) ||
-                (snake_posy[i] + 2 == b_pos.y + 3) ||
-                (snake_posy[i] + 2 == b_pos.y + 4) ||
-                (snake_posy[i] + 2 == b_pos.y + 5) ||
-                (snake_posy[i] + 2 == b_pos.y + 6) ||
-                (snake_posy[i] + 2 == b_pos.y + 7) ||
-                (snake_posy[i] + 2 == b_pos.y + 8) ||
-                (snake_posy[i] + 2 == b_pos.y + 9) ||
-                (snake_posy[i] + 2 == b_pos.y + 10)) &&
-                ((snake_posx[i] == b_pos.x + 18) ||  //E
-                (snake_posx[i] == b_pos.x + 50) ||  //E
-                (snake_posx[i] == b_pos.x + 82) ||  //E
-                (snake_posx[i] + 1 == b_pos.x + 18) ||  //E
-                (snake_posx[i] + 1 == b_pos.x + 50) ||  //E
-                (snake_posx[i] + 1 == b_pos.x + 82) ||  //E
-                (snake_posx[i] + 2 == b_pos.x + 18) ||  //E
-                (snake_posx[i] + 2 == b_pos.x + 50) ||  //E
-                (snake_posx[i] + 2 == b_pos.x + 82) ||  //E
-                (snake_posx[i] == b_pos.x + 2) ||  //E
-                (snake_posx[i] == b_pos.x + 34) ||  //E
-                (snake_posx[i] == b_pos.x + 66) ||  //E
-                (snake_posx[i] + 1 == b_pos.x + 2) ||  //E
-                (snake_posx[i] + 1 == b_pos.x + 34) ||  //E
-                (snake_posx[i] + 1 == b_pos.x + 66) ||  //E
-                (snake_posx[i] + 2 == b_pos.x + 2) ||  //E
-                (snake_posx[i] + 2 == b_pos.x + 34) ||  //E
-                (snake_posx[i] + 2 == b_pos.x + 66)))&&(d != W)) //E
-            ) {
-                //add some code that it doesn't move through
-                speed = 0;
-            }
+        if (
+            ((((snake_pos[i].y == b_pos.y + 1) ||
+            (snake_pos[i].y == b_pos.y + 1) ||
+            (snake_pos[i].y == b_pos.y + 2) ||
+            (snake_pos[i].y == b_pos.y + 3) ||
+            (snake_pos[i].y == b_pos.y + 4) ||
+            (snake_pos[i].y == b_pos.y + 5) ||
+            (snake_pos[i].y == b_pos.y + 6) ||
+            (snake_pos[i].y == b_pos.y + 7) ||
+            (snake_pos[i].y == b_pos.y + 8) ||
+            (snake_pos[i].y == b_pos.y + 9) ||
+            (snake_pos[i].y == b_pos.y + 10) ||
+            (snake_pos[i].y + 1 == b_pos.y) ||
+            (snake_pos[i].y + 1 == b_pos.y + 1) ||
+            (snake_pos[i].y + 1 == b_pos.y + 2) ||
+            (snake_pos[i].y + 1 == b_pos.y + 3) ||
+            (snake_pos[i].y + 1 == b_pos.y + 4) ||
+            (snake_pos[i].y + 1 == b_pos.y + 5) ||
+            (snake_pos[i].y + 1 == b_pos.y + 6) ||
+            (snake_pos[i].y + 1 == b_pos.y + 7) ||
+            (snake_pos[i].y + 1 == b_pos.y + 8) ||
+            (snake_pos[i].y + 1 == b_pos.y + 9) ||
+            (snake_pos[i].y + 1 == b_pos.y + 10) ||
+            (snake_pos[i].y + 2 == b_pos.y) ||
+            (snake_pos[i].y + 2 == b_pos.y + 1) ||
+            (snake_pos[i].y + 2 == b_pos.y + 2) ||
+            (snake_pos[i].y + 2 == b_pos.y + 3) ||
+            (snake_pos[i].y + 2 == b_pos.y + 4) ||
+            (snake_pos[i].y + 2 == b_pos.y + 5) ||
+            (snake_pos[i].y + 2 == b_pos.y + 6) ||
+            (snake_pos[i].y + 2 == b_pos.y + 7) ||
+            (snake_pos[i].y + 2 == b_pos.y + 8) ||
+            (snake_pos[i].y + 2 == b_pos.y + 9) ||
+            (snake_pos[i].y + 2 == b_pos.y + 10)) &&
+            ((snake_pos[i].x == b_pos.x + 18) ||  //E
+            (snake_pos[i].x == b_pos.x + 50) ||  //E
+            (snake_pos[i].x == b_pos.x + 82) ||  //E
+            (snake_pos[i].x + 1 == b_pos.x + 18) ||  //E
+            (snake_pos[i].x + 1 == b_pos.x + 50) ||  //E
+            (snake_pos[i].x + 1 == b_pos.x + 82) ||  //E
+            (snake_pos[i].x + 2 == b_pos.x + 18) ||  //E
+            (snake_pos[i].x + 2 == b_pos.x + 50) ||  //E
+            (snake_pos[i].x + 2 == b_pos.x + 82) ||  //E
+            (snake_pos[i].x == b_pos.x + 2) ||  //E
+            (snake_pos[i].x == b_pos.x + 34) ||  //E
+            (snake_pos[i].x == b_pos.x + 66) ||  //E
+            (snake_pos[i].x + 1 == b_pos.x + 2) ||  //E
+            (snake_pos[i].x + 1 == b_pos.x + 34) ||  //E
+            (snake_pos[i].x + 1 == b_pos.x + 66) ||  //E
+            (snake_pos[i].x + 2 == b_pos.x + 2) ||  //E
+            (snake_pos[i].x + 2 == b_pos.x + 34) ||  //E
+            (snake_pos[i].x + 2 == b_pos.x + 66)))&&(d != W)) //E
+        ) {
+            //add some code that it doesn't move through
+            speed = 0;
+        }
     }
 }
\ No newline at end of file