Rotation mostly works, T and S typed Borked atm

src/rewrite/block.h

@@ -2,7 +2,7 @@
 #define BLOCK_H_
 #include "point.h"
 
-/* Not sure where this should belong tbh */
+/* Not sure where this belongs tbh */
 #define BLOCKS_WITHIN_A_TETROMINO 4
 
 typedef enum btype_t {

src/rewrite/m_block.c

@@ -1,6 +1,7 @@
 #include "m_block.h"
 
 #include <limits.h>
+#include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
@@ -23,13 +24,14 @@ void (*on_block_spawn)(block_t *blocks[BLOCKS_WITHIN_A_TETROMINO]);
 
 void M_B_Create_Blocks(void) {
   int i;
+  block_t *block = NULL;
+
   for (i = 0; i < BLOCK_ARRAY_LENGTH; i++) {
-    block_t *block = malloc(sizeof(block_t));
+    block = malloc(sizeof(block_t));
     block->id = -1;
     block->point.x = i % BLOCK_ARRAY_COLUMNS;
     block->point.y = i / BLOCK_ARRAY_COLUMNS;
     block->type = bt_Empty;
-
     _blocks[i] = block;
   }
 }
@@ -55,6 +57,7 @@ block_t **M_B_Get_Updated_Blocks(int *length) {
 
 void M_B_Destroy_Blocks(void) {
   int i;
+
   for (i = 0; i < BLOCK_ARRAY_LENGTH; i++) {
     free(_blocks[i]);
   }
@@ -72,7 +75,6 @@ void M_B_Spawn_Blocks(void) {
   if (_next_block_type == bt_Empty) {
     M_B_Set_Next_Block_Type();
   }
-
   switch (_next_block_type) {
   case bt_I:
     offsets[0].x_offset = 0;
@@ -183,27 +185,24 @@ btype_t M_B_Get_Random_Block_Type(void) {
 }
 
 int M_B_Try_Spawn_Blocks_With_Offset(point_offset_t *offsets) {
-  int i = 0, kinda_unique_id = M_B_Generate_Block_Id();
+  int i = 0, unique_id = M_B_Generate_Block_Id();
   point_t spawn_point;
   block_t *spawn_block;
+
   while (i < BLOCKS_WITHIN_A_TETROMINO) {
     spawn_point.x = _spawn_x + offsets->x_offset;
     spawn_point.y = offsets->y_offset;
-
     spawn_block = M_B_Get_Block_At_Point(spawn_point);
     if (spawn_block->type != bt_Empty) {
       _can_spawn_tetromino_flag = 0;
       return 0;
     }
-    spawn_block->id = kinda_unique_id;
+    spawn_block->id = unique_id;
     M_B_Set_Block_Type(spawn_block, _next_block_type);
-
     _recently_spawned_blocks[i] = spawn_block;
-
     i++;
     offsets++;
   }
-
   return 1;
 }
 
@@ -225,19 +224,20 @@ void M_B_Register_Updated_block(block_t *block) {
 }
 
 int M_B_Can_Move_Blocks_Left(block_t **blocks) {
-  int i = 0, result = 1;
+  int i, result = 1;
-  for (; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+
+  for (i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     if (!M_B_Can_Move_Block_Left(*(blocks[i]))) {
       result = 0;
       break;
     }
   }
-
   return result;
 }
 
 int M_B_Can_Move_Block_Left(block_t block) {
   point_t left_adj_block_point;
+
   left_adj_block_point.x = block.point.x - 1;
   left_adj_block_point.y = block.point.y;
   if (left_adj_block_point.x < 0) {
@@ -253,28 +253,29 @@ int M_B_Can_Move_Block_Left(block_t block) {
 block_t *M_B_Move_Block_Left(block_t *block) {
   /* Kinda dupe from right and down, might consolidate */
   block_t *updated_block = M_B_Get_Block_At_Offset(block, _shift_left_offset);
+
   updated_block->id = block->id;
   M_B_Set_Block_Type(updated_block, block->type);
   block->id = -1;
   M_B_Set_Block_Type(block, bt_Empty);
-
   return updated_block;
 }
 
 int M_B_Can_Move_Blocks_Right(block_t **blocks) {
-  int i = 0, result = 1;
+  int i, result = 1;
-  for (; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+
+  for (i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     if (!M_B_Can_Move_Block_Right(*(blocks[i]))) {
       result = 0;
       break;
     }
   }
-
   return result;
 }
 
 int M_B_Can_Move_Block_Right(block_t block) {
   point_t right_adj_block_point;
+
   right_adj_block_point.x = block.point.x + 1;
   right_adj_block_point.y = block.point.y;
   if (right_adj_block_point.x >= BLOCK_ARRAY_COLUMNS) {
@@ -290,32 +291,32 @@ int M_B_Can_Move_Block_Right(block_t block) {
 
 block_t *M_B_Move_Block_Right(block_t *block) {
   block_t *updated_block = M_B_Get_Block_At_Offset(block, _shift_right_offset);
+
   updated_block->id = block->id;
   M_B_Set_Block_Type(updated_block, block->type);
   block->id = -1;
   M_B_Set_Block_Type(block, bt_Empty);
-
   return updated_block;
 }
 
 int M_B_Can_Move_Blocks_Down(block_t **blocks) {
-  int i = 0, result = 1;
+  int i, result = 1;
-  for (; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+
+  for (i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
     if (!M_B_Can_Move_Block_Down(*(blocks[i]))) {
       result = 0;
       break;
     }
   }
-
   if (!result) {
     _spawn_tetromino_flag = 1;
   }
-
   return result;
 }
 
 int M_B_Can_Move_Block_Down(block_t block) {
   point_t bottom_adj_block_point;
+
   bottom_adj_block_point.x = block.point.x;
   bottom_adj_block_point.y = block.point.y + 1;
   if (bottom_adj_block_point.y >= BLOCK_ARRAY_ROWS) {
@@ -330,25 +331,24 @@ int M_B_Can_Move_Block_Down(block_t block) {
 
 block_t *M_B_Move_Block_Down(block_t *block) {
   block_t *updated_block = M_B_Get_Block_At_Offset(block, _shift_down_offset);
+
   updated_block->id = block->id;
   M_B_Set_Block_Type(updated_block, block->type);
   block->id = -1;
   M_B_Set_Block_Type(block, bt_Empty);
-
   return updated_block;
 }
 
 block_t *M_B_Get_Block_At_Offset(block_t *block, point_offset_t offset) {
   point_t updated_point;
+
   updated_point.x = block->point.x + offset.x_offset;
   updated_point.y = block->point.y + offset.y_offset;
-
   return M_B_Get_Block_At_Point(updated_point);
 }
 
 int M_B_Point_Intersects_Static_Block(point_t point, int id) {
   int result = 0;
-
   block_t *block_at_point = M_B_Get_Block_At_Point(point);
 
   if (block_at_point->type != bt_Empty && block_at_point->id != id) {
@@ -367,16 +367,17 @@ int M_B_Generate_Block_Id(void) {
 
 int M_B_Can_Spawn_Blocks(void) { return _can_spawn_tetromino_flag; }
 
-/* TODO: make this update around point */
+/* TODO: There is an issue with S and T Type Rotations */
 block_t *M_B_Rotate_Block_Around_Point(block_t *block_to_rotate,
                                        point_t rotation_point) {
   point_offset_t offset, transposed_offset;
   block_t *updated_block,
       *origin_block = M_B_Get_Block_At_Point(rotation_point);
+  btype_t current_block_type = block_to_rotate->type;
+  int current_block_id = block_to_rotate->id;
 
   offset.x_offset = block_to_rotate->point.x - rotation_point.x;
   offset.y_offset = block_to_rotate->point.y - rotation_point.y;
-
   if (offset.x_offset > 0 || offset.x_offset < 0) {
     transposed_offset.x_offset = offset.y_offset;
     transposed_offset.y_offset = offset.x_offset * -1;
@@ -384,17 +385,10 @@ block_t *M_B_Rotate_Block_Around_Point(block_t *block_to_rotate,
     transposed_offset.x_offset = offset.y_offset;
     transposed_offset.y_offset = offset.x_offset;
   }
-
-  printf("Offset: %d,%d\n", transposed_offset.x_offset,
-         transposed_offset.y_offset);
-
-  /* This code is duplicated many places */
   updated_block = M_B_Get_Block_At_Offset(origin_block, transposed_offset);
-  updated_block->id = block_to_rotate->id;
-  M_B_Set_Block_Type(updated_block, block_to_rotate->type);
   block_to_rotate->id = -1;
   M_B_Set_Block_Type(block_to_rotate, bt_Empty);
-  printf("\nAddr %p != %p\n", updated_block, block_to_rotate);
+  updated_block->id = current_block_id;
-
+  M_B_Set_Block_Type(updated_block, current_block_type);
   return updated_block;
 }

src/rewrite/m_tetromino.c

@@ -3,7 +3,7 @@
 #include <limits.h>
 #include <stdlib.h>
 
-/* Blocks are gauranteed to be in order top left to bottom right */
+/* Blocks are gauranteed to be in order top to bottom order */
 block_t *_tetromino_blocks[BLOCKS_WITHIN_A_TETROMINO];
 point_t origin_point;
 int registered_flag = 0;
@@ -12,6 +12,7 @@ void M_T_Update_Tetromino(void) { M_T_Tetromino_Fall(); }
 
 void M_T_Tetromino_Fall(void) {
   int i;
+
   if (registered_flag && M_B_Can_Move_Blocks_Down(_tetromino_blocks)) {
     for (i = BLOCKS_WITHIN_A_TETROMINO - 1; i >= 0; i--) {
       _tetromino_blocks[i] = M_B_Move_Block_Down(_tetromino_blocks[i]);
@@ -22,6 +23,7 @@ void M_T_Tetromino_Fall(void) {
 
 void M_T_Register_Falling_Blocks(block_t *blocks[BLOCKS_WITHIN_A_TETROMINO]) {
   int i;
+
   if (!registered_flag) {
     registered_flag = 1;
   }
@@ -33,6 +35,7 @@ void M_T_Register_Falling_Blocks(block_t *blocks[BLOCKS_WITHIN_A_TETROMINO]) {
 
 void M_T_Move_Tetromino_Left(void) {
   int i;
+
   if (registered_flag && M_B_Can_Move_Blocks_Left(_tetromino_blocks)) {
     for (i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
       _tetromino_blocks[i] = M_B_Move_Block_Left(_tetromino_blocks[i]);
@@ -43,6 +46,7 @@ void M_T_Move_Tetromino_Left(void) {
 
 void M_T_Move_Tetromino_Right(void) {
   int i;
+
   if (registered_flag && M_B_Can_Move_Blocks_Right(_tetromino_blocks)) {
     for (i = BLOCKS_WITHIN_A_TETROMINO - 1; i >= 0; i--) {
       _tetromino_blocks[i] = M_B_Move_Block_Right(_tetromino_blocks[i]);
@@ -52,23 +56,22 @@ void M_T_Move_Tetromino_Right(void) {
 }
 
 int M_T_Block_Compare_Function(const void *a, const void *b) {
-  const block_t *block_a = a, *block_b = b;
+  const block_t *block_a = *(block_t **)a;
-  return block_a < block_b;
+  const block_t *block_b = *(block_t **)b;
+  return (block_a->point.y > block_b->point.y) -
+         (block_a->point.y < block_b->point.y);
 }
 
 void M_T_Rotate_Tetromino(void) {
   int i;
-  printf("\n\n");
+
-  for (i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
+  if (registered_flag && _tetromino_blocks[0]->type != bt_O) {
-    printf("%d: %p\n", i, (_tetromino_blocks[i]));
-  }
-  if (registered_flag) {
     for (i = 0; i < BLOCKS_WITHIN_A_TETROMINO; i++) {
       _tetromino_blocks[i] =
           M_B_Rotate_Block_Around_Point(_tetromino_blocks[i], origin_point);
     }
+    /* Sorting after rotating to keep blocks in descending order by Y */
     qsort(_tetromino_blocks, BLOCKS_WITHIN_A_TETROMINO, sizeof(block_t *),
           M_T_Block_Compare_Function);
   }
-  printf("\n\n");
 }

src/rewrite/tc_input.c

@@ -2,13 +2,14 @@
 #include "m_tetromino.h"
 #include "raylib.h"
 
-void TC_Process_Input_Per_Tick(void) {
+/* Was having issues with raylib input, wasn't having these
-  /* Was having issues with raylib input, wasn't having these
    issues before but I figured out that I can just cast to
    a char to get the result I want :)
 
    should look into what's going on though to understand better
-  */
+*/
+
+void TC_Process_Input_Per_Tick(void) {
   if ((char)IsKeyDown(KEY_A)) {
     M_T_Move_Tetromino_Left();
   } else if ((char)IsKeyDown(KEY_D)) {