checkpointHEADmain

3 files changed, 243 insertions, 316 deletions

diff --git a/app b/app
new file mode 100755
index 0000000..c3b6274
--- /dev/null
+++ b/app
diff --git a/build.sh b/build.sh
index 2644ef1..a50b82c 100755
--- a/build.sh
+++ b/build.sh
@@ -32,19 +32,5 @@ LDFLAGS="
 -lX11
 "
 
-build_debug() {
-    $CC $CFLAGS_COMMON $CFLAGS_DEBUG $SRC -o $OUT $LDFLAGS
-}
-
-build_release() {
-    $CC $CFLAGS_COMMON $CFLAGS_RELEASE $SRC -o $OUT $LDFLAGS
-}
-
-case "$1" in
-    debug)   build_debug ;;
-    release) build_release ;;
-    *)
-        echo "usage: $0 [debug|release]"
-        exit 1
-        ;;
-esac
+$CC $CFLAGS_COMMON $CFLAGS_DEBUG $SRC -o $OUT $LDFLAGS
+./app
diff --git a/tetris.c b/tetris.c
index f4765ab..de49c19 100644
--- a/tetris.c
+++ b/tetris.c
@@ -10,15 +10,15 @@
  *       Revision:  1.0
  *       Compiler:  gcc
  *
- *         Author:  nsrddyn, 
- *   Organization:  
+ *         Author:  nsrddyn,
+ *   Organization:
  *
  * =====================================================================================
  */
 
 #include <raylib.h>
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <time.h>
 
 // GAME SETTINGS
@@ -28,384 +28,325 @@
 #define TETROMINO_SIZE_HEIGHT 2
 #define TETROMINO_SIZE_WIDTH 4
 
-#define CYAN_I \
-    (Color) { 0, 255, 255, 255 }
-#define YELLOW_O \
-    (Color) { 255, 255, 102, 255 }
-#define PURPLE_T \
-    (Color) { 138, 43, 226, 255 }
-#define GREEN_S \
-    (Color) { 34, 139, 34, 255 }
-#define RED_Z \
-    (Color) { 255, 69, 0, 255 }
-#define BLUE_J \
-    (Color) { 70, 130, 180, 255 }
-#define ORANGE_L \
-    (Color) { 255, 140, 0, 255 }
+#define CYAN_I (Color){0, 255, 255, 255}
+#define YELLOW_O (Color){255, 255, 102, 255}
+#define PURPLE_T (Color){138, 43, 226, 255}
+#define GREEN_S (Color){34, 139, 34, 255}
+#define RED_Z (Color){255, 69, 0, 255}
+#define BLUE_J (Color){70, 130, 180, 255}
+#define ORANGE_L (Color){255, 140, 0, 255}
 
-// Window and Grid Settings
-static const int SCREEN_WIDTH   = 400;
-static const int SCREEN_HEIGHT  = 600;
-static const int COLUMNS = 10; // Default standardized value for the amount of COLUMNS
-static const int ROWS = 20;    // Default standardized value for the amount of ROWS
-static const int CELL_WIDTH = SCREEN_WIDTH / COLUMNS;
-static const int CELL_HEIGHT = SCREEN_HEIGHT / ROWS;
+#define SCREEN_WIDTH 400
+#define SCREEN_HEIGHT 600
+#define COLUMNS 10
+#define ROWS 20
+#define CELL_WIDTH SCREEN_WIDTH / COLUMNS
+#define CELL_HEIGHT SCREEN_HEIGHT / ROWS
 
 static int SCORE = 0;
 
-typedef struct
-{
-    int blocks[TETROMINO_SIZE_HEIGHT][TETROMINO_SIZE_WIDTH];
-    Color color;
-    int x;
-    int y;
+typedef struct {
+  int blocks[TETROMINO_SIZE_HEIGHT][TETROMINO_SIZE_WIDTH];
+  Color color;
+  int x;
+  int y;
 
 } TETROMINO;
 
 TETROMINO TETROMINOES[7] = {
     // Making the tetrominoes in an array design
-    {
-        {
-            {0, 0, 0, 0},
-            {1, 1, 1, 1},
-        },
-        CYAN_I,
-        COLUMNS / 2,
-        0},
+    {{
+         {0, 0, 0, 0},
+         {1, 1, 1, 1},
+     },
+     CYAN_I,
+     COLUMNS / 2,
+     0},
     // supposed to have 2 forms of rotations
     // default spawn location is: center
 
-    {
-        {
-            {0, 1, 1, 0},
-            {0, 1, 1, 0},
-        },
-        YELLOW_O,
-        COLUMNS / 2,
-        0},
+    {{
+         {0, 1, 1, 0},
+         {0, 1, 1, 0},
+     },
+     YELLOW_O,
+     COLUMNS / 2,
+     0},
     // supposed to have no rotation forms
     // default spawn location is: center
-    {
-        {
-            {0, 1, 0, 0},
-            {1, 1, 1, 0},
-        },
-        PURPLE_T,
-        0,
-        0},
+    {{
+         {0, 1, 0, 0},
+         {1, 1, 1, 0},
+     },
+     PURPLE_T,
+     0,
+     0},
     // flat side left center
     // 4 rotational forms
-    {
-        {
-            {0, 1, 1, 0},
-            {1, 1, 0, 0},
-        },
-        GREEN_S,
-        0,
-        0},
+    {{
+         {0, 1, 1, 0},
+         {1, 1, 0, 0},
+     },
+     GREEN_S,
+     0,
+     0},
     // left center
     // 4 rotational forms
-    {
-        {
-            {1, 1, 0, 0},
-            {0, 1, 1, 0},
-        },
-        RED_Z,
-        0,
-        0},
+    {{
+         {1, 1, 0, 0},
+         {0, 1, 1, 0},
+     },
+     RED_Z,
+     0,
+     0},
     // left center
     // 4 rotational forms
-    {
-        {
-            {1, 0, 0, 0},
-            {1, 1, 1, 0},
-        },
-        BLUE_J,
-        0,
-        0},
+    {{
+         {1, 0, 0, 0},
+         {1, 1, 1, 0},
+     },
+     BLUE_J,
+     0,
+     0},
     // flat side first and left center
     // 4 rotational forms
-    {
-        {
-            {0, 0, 1, 0},
-            {1, 1, 1, 0},
-        },
-        ORANGE_L,
-        0,
-        0},
+    {{
+         {0, 0, 1, 0},
+         {1, 1, 1, 0},
+     },
+     ORANGE_L,
+     0,
+     0},
     // flat side first and left center
     // 4 rotational forms
 };
 
-void DRAW_BACKGROUND_GRID()
-{
-    for (int i = 0; i <= COLUMNS; i++)
-    {
-        DrawLine(i * CELL_WIDTH, 0, i * CELL_WIDTH, SCREEN_HEIGHT, GRAY);
-    }
-    for (int j = 0; j <= ROWS; j++)
-    {
-        DrawLine(0, j * CELL_HEIGHT, SCREEN_WIDTH, j * CELL_HEIGHT, GRAY);
-    }
+void DRAW_BACKGROUND_GRID() {
+  for (int i = 0; i <= COLUMNS; i++) {
+    DrawLine(i * CELL_WIDTH, 0, i * CELL_WIDTH, SCREEN_HEIGHT, GRAY);
+  }
+  for (int j = 0; j <= ROWS; j++) {
+    DrawLine(0, j * CELL_HEIGHT, SCREEN_WIDTH, j * CELL_HEIGHT, GRAY);
+  }
 }
 
-int **CREATE_TETROMINOS_GRID(int rows, int columns)
-{
-    int **array = malloc(rows * sizeof(int *));
-    if (!array)
-        return NULL;
+int **CREATE_TETROMINOS_GRID(int rows, int columns) {
+  int **array = malloc(rows * sizeof(int *));
+  if (!array)
+    return NULL;
 
-    for (int i = 0; i < rows; i++)
+  for (int i = 0; i < rows; i++)
 
-    {
-        array[i] = calloc(columns, sizeof(int));
-        if (!array[i])
-        {
-            for (int j = 0; j < i; j++)
-                free(array[j]);
-            free(array);
-            return NULL;
-        }
+  {
+    array[i] = calloc(columns, sizeof(int));
+    if (!array[i]) {
+      for (int j = 0; j < i; j++)
+        free(array[j]);
+      free(array);
+      return NULL;
     }
-    return array;
+  }
+  return array;
 }
 
-void CHECK_FULL_LINE(int **GRID)
-{
-    for (int y = 0; y < ROWS; y++)
-    {
-        bool FULL_LINE = true;
+void CHECK_FULL_LINE(int **GRID) {
+  for (int y = 0; y < ROWS; y++) {
+    bool FULL_LINE = true;
 
-        for (int x = 0; x < COLUMNS; x++)
-        {
-            if (GRID[y][x] == 0)
-            {
-                FULL_LINE = false;
-                break;
-            }
-        }
+    for (int x = 0; x < COLUMNS; x++) {
+      if (GRID[y][x] == 0) {
+        FULL_LINE = false;
+        break;
+      }
+    }
 
-        if (FULL_LINE)
-        {
-            for (int i = y; i > 0; i--)
-            {
-                for (int x = 0; x < COLUMNS; x++)
-                    GRID[i][x] = GRID[i - 1][x];
-            }
+    if (FULL_LINE) {
+      for (int i = y; i > 0; i--) {
+        for (int x = 0; x < COLUMNS; x++)
+          GRID[i][x] = GRID[i - 1][x];
+      }
 
-            for (int x = 0; x < COLUMNS; x++)
-                GRID[ROWS - 2][x] = 0;
+      for (int x = 0; x < COLUMNS; x++)
+        GRID[ROWS - 2][x] = 0;
 
-            SCORE += 10;
-        }
+      SCORE += 10;
     }
+  }
 }
 
-
-
 // Detect if the active tetromino is hitting another tetromino
 // Detect if the active tetromino is hitting another tetromino
-int COLLISION_DETECTION(TETROMINO *tetromino, int **GRID)
-{
-    int TETROMINO_WIDTH = 0;
-    int TETROMINO_HEIGHT = 0;
+int COLLISION_DETECTION(TETROMINO *tetromino, int **GRID) {
+  int TETROMINO_WIDTH = 0;
+  int TETROMINO_HEIGHT = 0;
 
-    // Determine the bounding width and height of the tetromino
-    for (int y = 0; y < TETROMINO_SIZE_HEIGHT; y++)
-    {
-        for (int x = 0; x < TETROMINO_SIZE_WIDTH; x++)
-        {
-            if (tetromino->blocks[y][x] == 1)
-            {
-                // Update width and height based on the furthest active blocks
-                if (x + 1 > TETROMINO_WIDTH)
-                    TETROMINO_WIDTH = x + 1;
-                if (y + 1 > TETROMINO_HEIGHT)
-                    TETROMINO_HEIGHT = y + 1;
-            }
-        }
+  // Determine the bounding width and height of the tetromino
+  for (int y = 0; y < TETROMINO_SIZE_HEIGHT; y++) {
+    for (int x = 0; x < TETROMINO_SIZE_WIDTH; x++) {
+      if (tetromino->blocks[y][x] == 1) {
+        // Update width and height based on the furthest active blocks
+        if (x + 1 > TETROMINO_WIDTH)
+          TETROMINO_WIDTH = x + 1;
+        if (y + 1 > TETROMINO_HEIGHT)
+          TETROMINO_HEIGHT = y + 1;
+      }
     }
+  }
 
-    // Check for collision with the grid
-    for (int i = 0; i < TETROMINO_HEIGHT; i++)
-    {
-        for (int j = 0; j < TETROMINO_WIDTH; j++)
-        {
-            if (tetromino->blocks[i][j] == 1)
-            {
-                int GRID_X = tetromino->x + j;
-                int GRID_Y = tetromino->y + i;
+  // Check for collision with the grid
+  for (int i = 0; i < TETROMINO_HEIGHT; i++) {
+    for (int j = 0; j < TETROMINO_WIDTH; j++) {
+      if (tetromino->blocks[i][j] == 1) {
+        int GRID_X = tetromino->x + j;
+        int GRID_Y = tetromino->y + i;
 
-                // Check if we are within the grid boundaries and if there is a block
-                if (GRID_Y >= 0 && GRID_X >= 0 && GRID[GRID_Y][GRID_X] != 0)
-                {
-                    return 1; // Collision detected
-                }
-            }
+        // Check if we are within the grid boundaries and if there is a block
+        if (GRID_Y >= 0 && GRID_X >= 0 && GRID[GRID_Y][GRID_X] != 0) {
+          return 1; // Collision detected
         }
+      }
     }
+  }
 
-    // No collision
-    return 0;
+  // No collision
+  return 0;
 }
-int *ROTATE_ACTIVE_TETROMINO(TETROMINO *tetromino, int **GRID)
-{
-    int *ROTATED_TETROMINO;
+int *ROTATE_ACTIVE_TETROMINO(TETROMINO *tetromino, int **GRID) {
+  int *ROTATED_TETROMINO;
 
-    for (int x = 0; x < COLUMNS; x++)
-    {
-        for (int y = 0; y < ROWS; y++)
-        {
-            ROTATED_TETROMINO = 0;
-        }
+  for (int x = 0; x < COLUMNS; x++) {
+    for (int y = 0; y < ROWS; y++) {
+      ROTATED_TETROMINO = 0;
     }
-    return ROTATED_TETROMINO;
+  }
+  return ROTATED_TETROMINO;
 }
 
-void FREE_GRID(int **array, int rows)
-{
-    for (int i = 0; i < rows; i++)
-        free(array[i]);
-    free(array);
+void FREE_GRID(int **array, int rows) {
+  for (int i = 0; i < rows; i++)
+    free(array[i]);
+  free(array);
 }
 
-void DRAW_TETROMINO(TETROMINO *tetromino)
-{
-    for (int y = 0; y < TETROMINO_SIZE_HEIGHT; y++)
-    {
-        for (int x = 0; x < TETROMINO_SIZE_WIDTH; x++)
-        {
-            if (tetromino->blocks[y][x] == 1)
-            {
-                DrawRectangle(
-                    (tetromino->x + x) * CELL_WIDTH,
-                    (tetromino->y + y) * CELL_HEIGHT,
-                    CELL_WIDTH, CELL_HEIGHT,
-                    tetromino->color);
-            }
-        }
+void DRAW_TETROMINO(TETROMINO *tetromino) {
+  for (int y = 0; y < TETROMINO_SIZE_HEIGHT; y++) {
+    for (int x = 0; x < TETROMINO_SIZE_WIDTH; x++) {
+      if (tetromino->blocks[y][x] == 1) {
+        DrawRectangle((tetromino->x + x) * CELL_WIDTH,
+                      (tetromino->y + y) * CELL_HEIGHT, CELL_WIDTH, CELL_HEIGHT,
+                      tetromino->color);
+      }
     }
+  }
 }
 
-TETROMINO SPAWN_TETROMINO()
-{
-    int RANDOM_INDEX = GetRandomValue(0, 6);
-    TETROMINO tetromino = TETROMINOES[RANDOM_INDEX];
+TETROMINO SPAWN_TETROMINO() {
+  int RANDOM_INDEX = GetRandomValue(0, 6);
+  TETROMINO tetromino = TETROMINOES[RANDOM_INDEX];
 
-    if (tetromino.x == 0)
-    {
-        tetromino.x = COLUMNS / 2 - 2;
-        tetromino.y = 0;
-    }
-    return tetromino;
+  if (tetromino.x == 0) {
+    tetromino.x = COLUMNS / 2 - 2;
+    tetromino.y = 0;
+  }
+  return tetromino;
 }
 
-void MOVE_TETROMINO(TETROMINO *tetromino, int **GRID)
-{
-    // RIGHT WALL COLLISION DETECTION BY STOPPING MOVEMENT
-    if (IsKeyDown(KEY_RIGHT) && COLLISION_DETECTION(tetromino, GRID) == 0 && tetromino->x < COLUMNS - 2)
-        tetromino->x++;
-    // LEFT WALL COLLISION DETECTION BY STOPPING MOVEMENT
-    if (IsKeyDown(KEY_LEFT) && COLLISION_DETECTION(tetromino, GRID) == 0 && tetromino->x > 0)
-        tetromino->x--;
-    // BOTTOM ROW COLLISION DETECTION BY STOPPING MOVEMENT
-    if (IsKeyDown(KEY_DOWN) && COLLISION_DETECTION(tetromino, GRID) == 0 && tetromino->y < ROWS - 2)
-        tetromino->y++;
+void MOVE_TETROMINO(TETROMINO *tetromino, int **GRID) {
+  // RIGHT WALL COLLISION DETECTION BY STOPPING MOVEMENT
+  if (IsKeyDown(KEY_RIGHT) && COLLISION_DETECTION(tetromino, GRID) == 0 &&
+      tetromino->x < COLUMNS - 2)
+    tetromino->x++;
+  // LEFT WALL COLLISION DETECTION BY STOPPING MOVEMENT
+  if (IsKeyDown(KEY_LEFT) && COLLISION_DETECTION(tetromino, GRID) == 0 &&
+      tetromino->x > 0)
+    tetromino->x--;
+  // BOTTOM ROW COLLISION DETECTION BY STOPPING MOVEMENT
+  if (IsKeyDown(KEY_DOWN) && COLLISION_DETECTION(tetromino, GRID) == 0 &&
+      tetromino->y < ROWS - 2)
+    tetromino->y++;
 }
 
-void SAVE_TETROMINO(TETROMINO *tetromino, int **GRID)
-{
-    for (int y = 0; y < TETROMINO_SIZE_HEIGHT; y++)
-    {
-        for (int x = 0; x < TETROMINO_SIZE_WIDTH; x++)
-        {
-            if (tetromino->blocks[y][x] == 1)
-            {
-                int GRIDX = tetromino->x + x;
-                int GRIDY = tetromino->y + y;
-                if (GRIDX < COLUMNS && GRIDY >= 0 && GRIDY < ROWS)
-                    GRID[GRIDY][GRIDX] = 1;
-            }
-        }
+void SAVE_TETROMINO(TETROMINO *tetromino, int **GRID) {
+  for (int y = 0; y < TETROMINO_SIZE_HEIGHT; y++) {
+    for (int x = 0; x < TETROMINO_SIZE_WIDTH; x++) {
+      if (tetromino->blocks[y][x] == 1) {
+        int GRIDX = tetromino->x + x;
+        int GRIDY = tetromino->y + y;
+        if (GRIDX < COLUMNS && GRIDY >= 0 && GRIDY < ROWS)
+          GRID[GRIDY][GRIDX] = 1;
+      }
     }
+  }
 }
 
-void DRAW_SAVED_TETROMINO(int **GRID, TETROMINO *tetromino)
-{
-    for (int y = 0; y < ROWS; y++)
-    {
-        for (int x = 0; x < COLUMNS; x++)
-        {
-            if (GRID[y][x] == 1)
-                DrawRectangle((x * CELL_WIDTH), (y * CELL_HEIGHT), CELL_WIDTH, CELL_HEIGHT, tetromino->color);
-        }
+void DRAW_SAVED_TETROMINO(int **GRID, TETROMINO *tetromino) {
+  for (int y = 0; y < ROWS; y++) {
+    for (int x = 0; x < COLUMNS; x++) {
+      if (GRID[y][x] == 1)
+        DrawRectangle((x * CELL_WIDTH), (y * CELL_HEIGHT), CELL_WIDTH,
+                      CELL_HEIGHT, tetromino->color);
     }
+  }
 }
 
-void DRAW_STATS(TETROMINO *tetromino)
-{
-    char SCORE_TEXT[16];
-    sprintf(SCORE_TEXT, "SCORE: %d", SCORE);
-    DrawText(SCORE_TEXT, 10, 10, FONT_SIZE, BLUE);
+void DRAW_STATS(TETROMINO *tetromino) {
+  char SCORE_TEXT[16];
+  sprintf(SCORE_TEXT, "SCORE: %d", SCORE);
+  DrawText(SCORE_TEXT, 10, 10, FONT_SIZE, BLUE);
 
-    char CURRENT_Y_POSITION[32], CURRENT_X_POSITION[32];
-    sprintf(CURRENT_Y_POSITION, "Y COÖRDINATE: %d", tetromino->y);
-    sprintf(CURRENT_X_POSITION, "X COÖRDINATE: %d", tetromino->x);
-    DrawText(CURRENT_Y_POSITION, 10, 50, FONT_SIZE, BLUE);
-    DrawText(CURRENT_X_POSITION, 10, 80, FONT_SIZE, BLUE);
+  char CURRENT_Y_POSITION[32], CURRENT_X_POSITION[32];
+  sprintf(CURRENT_Y_POSITION, "Y COÖRDINATE: %d", tetromino->y);
+  sprintf(CURRENT_X_POSITION, "X COÖRDINATE: %d", tetromino->x);
+  DrawText(CURRENT_Y_POSITION, 10, 50, FONT_SIZE, BLUE);
+  DrawText(CURRENT_X_POSITION, 10, 80, FONT_SIZE, BLUE);
 
-    int POS_X = SCREEN_WIDTH    / 2;
-    int POS_Y = SCREEN_HEIGHT   / 2;
+  int POS_X = SCREEN_WIDTH / 2;
+  int POS_Y = SCREEN_HEIGHT / 2;
 
-    const char ERROR_TEXT[] = "LOW FPS";
-    if (GetFPS() < 40)
-        DrawText(ERROR_TEXT, POS_X, POS_Y, FONT_SIZE, RED);
+  const char ERROR_TEXT[] = "LOW FPS";
+  if (GetFPS() < 40)
+    DrawText(ERROR_TEXT, POS_X, POS_Y, FONT_SIZE, RED);
 }
 
-int main()
-{
-    // Initialize the window and set the wanted FPS
-    InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Tetris");
-    SetTargetFPS(FPS);
-
+int main() {
+  // Initialize the window and set the wanted FPS
+  InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Tetris");
+  SetTargetFPS(FPS);
 
-    // Spawn a new tetromino
-    TETROMINO ACTIVE_TETROMINO = SPAWN_TETROMINO();
+  // Spawn a new tetromino
+  TETROMINO ACTIVE_TETROMINO = SPAWN_TETROMINO();
 
-    int **GRID = CREATE_TETROMINOS_GRID(ROWS, COLUMNS);
-    if (!GRID)
-    {
-        printf("Failed to allocate memory for the grid.");
-        CloseWindow();
-        return 1;
-    }
-
-    while (!WindowShouldClose())
-    {
-        BeginDrawing();
-        ClearBackground(BLACK);
-
-        DRAW_BACKGROUND_GRID();
-        DRAW_SAVED_TETROMINO(GRID, &ACTIVE_TETROMINO);
-        DRAW_TETROMINO(&ACTIVE_TETROMINO);
-        DRAW_STATS(&ACTIVE_TETROMINO);
+  int **GRID = CREATE_TETROMINOS_GRID(ROWS, COLUMNS);
+  if (!GRID) {
+    printf("Failed to allocate memory for the grid.");
+    CloseWindow();
+    return 1;
+  }
 
-        MOVE_TETROMINO(&ACTIVE_TETROMINO, GRID);
+  while (!WindowShouldClose()) {
+    BeginDrawing();
+    ClearBackground(BLACK);
 
-        if (ACTIVE_TETROMINO.y == ROWS - 2 || COLLISION_DETECTION(&ACTIVE_TETROMINO, GRID) != 0)
-        {
-            SCORE++;
-            SAVE_TETROMINO(&ACTIVE_TETROMINO, GRID);
-            ACTIVE_TETROMINO = SPAWN_TETROMINO();
-            printf("DEBUGGING INFORMATION - XOR %p: ",&ACTIVE_TETROMINO.x);
-            printf("DEBUGGING INFORMATION - YOR %p: ",&ACTIVE_TETROMINO.y);
+    DRAW_BACKGROUND_GRID();
+    DRAW_SAVED_TETROMINO(GRID, &ACTIVE_TETROMINO);
+    DRAW_TETROMINO(&ACTIVE_TETROMINO);
+    DRAW_STATS(&ACTIVE_TETROMINO);
 
-        }
+    MOVE_TETROMINO(&ACTIVE_TETROMINO, GRID);
 
-        EndDrawing();
+    if (ACTIVE_TETROMINO.y == ROWS - 2 ||
+        COLLISION_DETECTION(&ACTIVE_TETROMINO, GRID) != 0) {
+      SCORE++;
+      SAVE_TETROMINO(&ACTIVE_TETROMINO, GRID);
+      ACTIVE_TETROMINO = SPAWN_TETROMINO();
+      printf("DEBUGGING INFORMATION - XOR %p: ", &ACTIVE_TETROMINO.x);
+      printf("DEBUGGING INFORMATION - YOR %p: ", &ACTIVE_TETROMINO.y);
     }
 
-    FREE_GRID(GRID, ROWS);
-    CloseWindow();
-    return 0;
+    EndDrawing();
+  }
+
+  FREE_GRID(GRID, ROWS);
+  CloseWindow();
+  return 0;
 }