run formatter

.gitignore

@@ -1 +1 @@
-./src/tetris-clone
+tetris-clone

src/app.c

@@ -1,10 +1,10 @@
 #include <stdio.h>
 
-#include "raylib.h"
+#include "app.h"
 #include "manager.h"
+#include "raylib.h"
 #include "renderer.h"
 #include "tetromino.h"
-#include "app.h"
 
 #define TARGET_FPS 60
 
@@ -29,21 +29,25 @@ void _a_initialize_raylib(void) {
 void _a_gameboard_clear(void) {
   m_blocks_set_empty();
   int number_blocks_updated = 0;
-    struct TetrominoBlock** blocks_updated = m_blocks_get_updated(&number_blocks_updated);
+  struct TetrominoBlock **blocks_updated =
+      m_blocks_get_updated(&number_blocks_updated);
   r_render_blocks(blocks_updated, number_blocks_updated);
 }
 
 void _a_loop(void) {
   int tick_rate = 0; // Guaranteed a better way to do this XD
-    while(!WindowShouldClose()) {
+  while (!WindowShouldClose()) {
-        while(m_tetromino_can_spawn()) {
+    while (m_tetromino_can_spawn()) {
+      if (WindowShouldClose())
+        return;
       _a_input_process();
       if (tick_rate == 0) {
         m_update();
         tick_rate = 50;
       }
       int number_blocks_updated = 0;
-            struct TetrominoBlock** blocks_updated = GetUpdatedBlocks(&number_blocks_updated);
+      struct TetrominoBlock **blocks_updated =
+          m_blocks_get_updated(&number_blocks_updated);
       r_render_blocks(blocks_updated, number_blocks_updated);
       tick_rate--;
     }

src/manager.c

@@ -22,22 +22,44 @@ struct Point {
 
 struct Tetromino {
   enum TetrominoType type;
-    struct TetrominoBlock* blocks[BLOCKS_WITHIN_A_TETROMINO];
+  struct TetrominoBlock *blocks[BLOCKS_WITHIN_A_TETROMINO];
 };
 
+struct TetrominoBlock *_m_block_at_point(struct Point point);
+void _m_blocks_updated_register_block(struct TetrominoBlock *pTetrominoBlock);
+void _m_blocks_alloc(void);
+void _m_blocks_updated_erase(void);
+void _m_blocks_spawn_at_offset_from_spawn_point(enum TetrominoType type,
+                                                struct Offset *offsets);
+void _m_tetromino_spawn(void);
+enum TetrominoType _m_tetromino_type_random(void);
+void _m_block_set_type(struct TetrominoBlock *pTetrominoBlock,
+                       enum TetrominoType type);
+void _m_falling_tetromino_rotate(void);
+bool _m_falling_tetromino_can_move_right(void);
+void _m_falling_tetromino_translate(struct Offset offset);
+bool _m_point_intersects_static_block(struct Point point);
+bool _m_block_can_fall(struct TetrominoBlock block);
+bool _m_falling_tetromino_can_fall(void);
+void _m_falling_tetromino_fall(void);
+bool _m_block_can_move_left(struct TetrominoBlock block);
+bool _m_falling_tetromino_can_move_left(void);
+bool _m_block_can_move_right(struct TetrominoBlock block);
+
 // To find block (x,y) index = (x % FIELD_WIDTH) + (y * FIELD_WIDTH)
-//    Height doesn't matter but height is just the factor of how tall the board is. 
+//    Height doesn't matter but height is just the factor of how tall the board
-//    And in the end each row is just the next representation of width * units, height just determines row count.
+//    is. And in the end each row is just the next representation of width *
-//    Doesn't factor into determining X,Y
+//    units, height just determines row count. Doesn't factor into determining
-struct TetrominoBlock* _blocks[FIELD_HEIGHT * FIELD_WIDTH];
+//    X,Y
-struct TetrominoBlock* _blocks_updated[FIELD_HEIGHT * FIELD_WIDTH] = { NULL };
+struct TetrominoBlock *_blocks[FIELD_HEIGHT * FIELD_WIDTH];
+struct TetrominoBlock *_blocks_updated[FIELD_HEIGHT * FIELD_WIDTH] = {NULL};
 int _blocks_updated_length = 0;
 bool _should_spawn_tetromino;
 struct Tetromino fallingTetromino;
 const char kSpawnX = FIELD_WIDTH / 2 - 1;
-const struct Offset kShiftDownOffset = { .xOffset = 0, .yOffset = 1 };
+const struct Offset kShiftDownOffset = {.xOffset = 0, .yOffset = 1};
-const struct Offset kShiftLeftOffset = { .xOffset = -1, .yOffset = 0 };
+const struct Offset kShiftLeftOffset = {.xOffset = -1, .yOffset = 0};
-const struct Offset kShiftRightOffset = { .xOffset = 1, .yOffset = 0 };
+const struct Offset kShiftRightOffset = {.xOffset = 1, .yOffset = 0};
 
 bool _should_tetromino_move_left = false;
 bool _should_tetromino_move_right = false;
@@ -59,7 +81,7 @@ void m_update(void) {
   } else {
     // TODO move left and right refactor naming
 
-        if(_should_tetromino_rotate) {
+    if (_should_tetromino_rotate) {
       _m_falling_tetromino_rotate();
       _should_tetromino_rotate = false;
     }
@@ -84,9 +106,7 @@ void m_blocks_set_empty(void) {
   }
 }
 
-bool m_tetromino_can_spawn(void) {
+bool m_tetromino_can_spawn(void) { return _tetromino_can_spawn; }
-    return _tetromino_can_spawn;
-}
 
 void m_request_falling_tetromino_rotate(void) {
   _should_tetromino_rotate = true;
@@ -102,21 +122,21 @@ void m_request_falling_tetromino_move_right(void) {
   _should_tetromino_move_left = false;
 }
 
-struct TetrominoBlock** m_blocks_get_updated(int* numberOfUpdatedBlocks) {
+struct TetrominoBlock **m_blocks_get_updated(int *numberOfUpdatedBlocks) {
   *numberOfUpdatedBlocks = _blocks_updated_length;
 
   return &_blocks_updated[0];
 }
 
 void m_deactivate(void) {
-    for(int i = 0; i < sizeof(_blocks) / sizeof(struct TetrominoBlock*); i++) {
+  for (int i = 0; i < sizeof(_blocks) / sizeof(struct TetrominoBlock *); i++) {
     free(_blocks[i]);
   }
 }
 
 void _m_blocks_alloc(void) {
   for (int i = 0; i < FIELD_HEIGHT * FIELD_WIDTH; i++) {
-        struct TetrominoBlock* block = calloc(1, sizeof(struct TetrominoBlock));
+    struct TetrominoBlock *block = calloc(1, sizeof(struct TetrominoBlock));
     block->x = i % FIELD_WIDTH;
     block->y = i / FIELD_WIDTH;
 
@@ -124,12 +144,10 @@ void _m_blocks_alloc(void) {
   }
 }
 
-void _m_blocks_updated_erase() {
+void _m_blocks_updated_erase() { _blocks_updated_length = 0; }
-    _blocks_updated_length = 0;
-}
 
 void _m_tetromino_spawn() {
-    enum TetrominoType type = _m_tetromino_type_get_random();
+  enum TetrominoType type = _m_tetromino_type_random();
 
   struct Offset offsets[BLOCKS_WITHIN_A_TETROMINO];
 
@@ -224,25 +242,27 @@ void _m_tetromino_spawn() {
 
 enum TetrominoType _m_tetromino_type_random(void) {
   srand(time(NULL));
-    return (enum TetrominoType) rand() % 6;
+  return (enum TetrominoType)rand() % 6;
 }
 
-void _m_blocks_spawn_at_offset_from_spawn_point(enum TetrominoType type, struct Offset *offsets) {
+void _m_blocks_spawn_at_offset_from_spawn_point(enum TetrominoType type,
+                                                struct Offset *offsets) {
   fallingTetromino.type = type;
   int index = 0;
-    while(index < BLOCKS_WITHIN_A_TETROMINO) {
+  while (index < BLOCKS_WITHIN_A_TETROMINO) {
     struct Point spawnPoint;
     spawnPoint.x = kSpawnX + offsets->xOffset;
     spawnPoint.y = offsets->yOffset;
 
-        struct TetrominoBlock* spawnBlock = _m_block_at_point(spawnPoint);
+    struct TetrominoBlock *spawnBlock = _m_block_at_point(spawnPoint);
     if (spawnBlock->type != TT_EMPTY) {
       _tetromino_can_spawn = false;
       return;
     }
     _m_block_set_type(spawnBlock, type);
 
-        // I'm not sure if this makes more sense to be here or return a list of spawnedBlocks to be handled in Parent function
+    // I'm not sure if this makes more sense to be here or return a list of
+    // spawnedBlocks to be handled in Parent function
     fallingTetromino.blocks[index] = spawnBlock;
 
     index++;
@@ -254,7 +274,8 @@ struct TetrominoBlock *_m_block_at_point(struct Point point) {
   return _blocks[(point.x % FIELD_WIDTH) + (point.y * FIELD_WIDTH)];
 }
 
-void _m_block_set_type(struct TetrominoBlock *pTetrominoBlock, enum TetrominoType type) {
+void _m_block_set_type(struct TetrominoBlock *pTetrominoBlock,
+                       enum TetrominoType type) {
   pTetrominoBlock->type = type;
   _m_blocks_updated_register_block(pTetrominoBlock);
 }
@@ -271,13 +292,12 @@ void _m_falling_tetromino_rotate(void) {
     // i'm not a fan of this implementation
     // check this out instead and re-write
     // https://stackoverflow.com/questions/42519/how-do-you-rotate-a-two-dimensional-array?page=1&tab=scoredesc#tab-top
-
   }
 }
 
 bool _m_falling_tetromino_can_move_right(void) {
   bool result = true;
-    for(int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+  for (int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     if (!_m_block_can_move_right(*(fallingTetromino.blocks[i]))) {
       result = false;
       break;
@@ -288,13 +308,15 @@ bool _m_falling_tetromino_can_move_right(void) {
 }
 
 void _m_falling_tetromino_translate(struct Offset offset) {
-    for(int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+  for (int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     _m_block_set_type(fallingTetromino.blocks[i], TT_EMPTY);
     _m_blocks_updated_register_block(fallingTetromino.blocks[i]);
   }
 
-    for(int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+  for (int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
-        struct Point updatedPoint = { .x = fallingTetromino.blocks[i]->x + offset.xOffset, .y = fallingTetromino.blocks[i]->y + offset.yOffset};
+    struct Point updatedPoint = {
+        .x = fallingTetromino.blocks[i]->x + offset.xOffset,
+        .y = fallingTetromino.blocks[i]->y + offset.yOffset};
     fallingTetromino.blocks[i] = _m_block_at_point(updatedPoint);
 
     _m_block_set_type(fallingTetromino.blocks[i], fallingTetromino.type);
@@ -305,12 +327,12 @@ void _m_falling_tetromino_translate(struct Offset offset) {
 bool _m_point_intersects_static_block(struct Point point) {
   bool result = false;
 
-    struct TetrominoBlock* blockAtPoint = _m_block_at_point(point);
+  struct TetrominoBlock *blockAtPoint = _m_block_at_point(point);
 
   if (blockAtPoint->type != TT_EMPTY) {
     result = true;
 
-        for(int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+    for (int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
       if (fallingTetromino.blocks[i] == blockAtPoint) {
         result = false;
         break;
@@ -322,7 +344,7 @@ bool _m_point_intersects_static_block(struct Point point) {
 }
 
 bool _m_block_can_fall(struct TetrominoBlock block) {
-    struct Point newBlockPoint = { .x = block.x, .y = block.y + 1};
+  struct Point newBlockPoint = {.x = block.x, .y = block.y + 1};
   if (newBlockPoint.y >= FIELD_HEIGHT) {
     return false;
   } else if (_m_point_intersects_static_block(newBlockPoint)) {
@@ -334,7 +356,7 @@ bool _m_block_can_fall(struct TetrominoBlock block) {
 
 bool _m_falling_tetromino_can_fall(void) {
   bool result = true;
-    for(int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+  for (int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     if (!_m_block_can_fall(*(fallingTetromino.blocks[i]))) {
       result = false;
       break;
@@ -345,7 +367,7 @@ bool _m_falling_tetromino_can_fall(void) {
 }
 
 void _m_falling_tetromino_fall(void) {
-    if(_m_falling_tetromino_can_fall()) {
+  if (_m_falling_tetromino_can_fall()) {
     _m_falling_tetromino_translate(kShiftDownOffset);
   } else {
     _should_spawn_tetromino = true;
@@ -353,7 +375,7 @@ void _m_falling_tetromino_fall(void) {
 }
 
 bool _m_block_can_move_left(struct TetrominoBlock block) {
-    struct Point newBlockPoint = { .x = block.x - 1, .y = block.y };
+  struct Point newBlockPoint = {.x = block.x - 1, .y = block.y};
   if (newBlockPoint.x < 0) {
     return false;
   } else if (_m_point_intersects_static_block(newBlockPoint)) {
@@ -365,7 +387,7 @@ bool _m_block_can_move_left(struct TetrominoBlock block) {
 
 bool _m_falling_tetromino_can_move_left(void) {
   bool result = true;
-    for(int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+  for (int i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     if (!_m_block_can_move_left(*(fallingTetromino.blocks[i]))) {
       result = false;
       break;
@@ -376,7 +398,7 @@ bool _m_falling_tetromino_can_move_left(void) {
 }
 
 bool _m_block_can_move_right(struct TetrominoBlock block) {
-    struct Point newBlockPoint = { .x = block.x + 1, .y = block.y };
+  struct Point newBlockPoint = {.x = block.x + 1, .y = block.y};
   if (newBlockPoint.x >= FIELD_WIDTH) {
     return false;
   } else if (_m_point_intersects_static_block(newBlockPoint)) {

src/manager.h

@@ -12,7 +12,7 @@ bool m_tetromino_can_spawn(void); // Bad name + Doesn't follow naming
 void m_request_falling_tetromino_rotate(void);
 void m_request_falling_tetromino_move_left(void);
 void m_request_falling_tetromino_move_right(void);
-struct TetrominoBlock* *m_blocks_get_updated(int* lengthOfBlocksUpdated);
+struct TetrominoBlock **m_blocks_get_updated(int *lengthOfBlocksUpdated);
 void m_deactivate(void);
 
 #endif

src/renderer.c

@@ -15,7 +15,7 @@ Texture2D _empty_texture;
 void r_initialize(void) {
   _yellow_texture = LoadTexture(RES_PNG_FILE(yellow));
   _blue_texture = LoadTexture(RES_PNG_FILE(blue));
-    _light_blue_texture = LoadTexture(RES_PNG_FILE(light-blue));
+  _light_blue_texture = LoadTexture(RES_PNG_FILE(light - blue));
   _red_texture = LoadTexture(RES_PNG_FILE(red));
   _purple_texture = LoadTexture(RES_PNG_FILE(purple));
   _green_texture = LoadTexture(RES_PNG_FILE(green));
@@ -23,9 +23,9 @@ void r_initialize(void) {
   _empty_texture = LoadTexture(RES_PNG_FILE(black));
 }
 
-void r_render_blocks(struct TetrominoBlock* *blocks, int length) {
+void r_render_blocks(struct TetrominoBlock **blocks, int length) {
   BeginDrawing();
-    while(length--) {
+  while (length--) {
     _r_render_block(*(*blocks));
     blocks++;
   }
@@ -35,19 +35,23 @@ void r_render_blocks(struct TetrominoBlock* *blocks, int length) {
 void r_render_game_over(int score) {
   BeginDrawing();
   ClearBackground(BLACK);
-    DrawText("Game Over", SCREEN_WIDTH / 2 - MeasureText("Game Over", 24) / 2, 200, 24, RED);
+  DrawText("Game Over", SCREEN_WIDTH / 2 - MeasureText("Game Over", 24) / 2,
-    char* score_message = TextFormat("Score: %d", score);
+           200, 24, RED);
-    DrawText(score_message, SCREEN_WIDTH / 2 - MeasureText(score_message, 18) / 2, 232, 18, RED);
+  char *score_message = TextFormat("Score: %d", score);
+  DrawText(score_message, SCREEN_WIDTH / 2 - MeasureText(score_message, 18) / 2,
+           232, 18, RED);
   // Draw a play again button
   EndDrawing();
 }
 
 void _r_render_block(struct TetrominoBlock blockToRender) {
-    Texture2D* textureToRender = _r_get_texture_by_tetromino_type(blockToRender.type);
+  Texture2D *textureToRender =
-    DrawTexture(*textureToRender, blockToRender.x * TEXTURE_SIZE, blockToRender.y * TEXTURE_SIZE, WHITE); 
+      _r_get_texture_by_tetromino_type(blockToRender.type);
+  DrawTexture(*textureToRender, blockToRender.x * TEXTURE_SIZE,
+              blockToRender.y * TEXTURE_SIZE, WHITE);
 }
 
-Texture2D* _r_get_texture_by_tetromino_type(enum TetrominoType type) {
+Texture2D *_r_get_texture_by_tetromino_type(enum TetrominoType type) {
   switch (type) {
   case TT_O:
     return &_yellow_texture;

src/renderer.h

@@ -8,7 +8,7 @@
 #define SCREEN_WIDTH 320
 
 void r_initialize(void);
-void r_render_blocks(struct TetrominoBlock* *blocks, int length);
+void r_render_blocks(struct TetrominoBlock **blocks, int length);
 void r_render_game_over(int score);
 
 void _r_render_block(struct TetrominoBlock blockToRender);

src/tetromino.h

@@ -1,16 +1,7 @@
 #ifndef TETRIS_CLONE_TETROMINO_H_
 #define TETRIS_CLONE_TETROMINO_H_
 
-enum TetrominoType {
+enum TetrominoType { TT_I, TT_J, TT_L, TT_O, TT_S, TT_T, TT_Z, TT_EMPTY };
-  TT_I,
-  TT_J,
-  TT_L,
-  TT_O,
-  TT_S,
-  TT_T,
-  TT_Z,
-  TT_EMPTY 
-};
 
 struct TetrominoBlock {
   unsigned int x;