consistent formatting plus cleanup

4 files changed, 199 insertions, 201 deletions

diff --git a/lib/cetris.h b/lib/cetris.h
index 6f3ea77..a400779 100755
--- a/lib/cetris.h
+++ b/lib/cetris.h
@@ -18,12 +18,12 @@ typedef struct
 
 typedef unsigned char ctrs_matrix[4];
 
-enum 
+enum
 {
   CTRS_SLOT_OCCUPIED = 1,
 };
 
-typedef enum 
+typedef enum
 {
   MINO_Z,
   MINO_L,
@@ -35,14 +35,14 @@ typedef enum
 } ctrs_mino_type;
 
 typedef enum
-{ 
-  INIT, 
-  ONCE_RIGHT, 
-  TWICE, 
-  ONCE_LEFT 
+{
+  INIT,
+  ONCE_RIGHT,
+  TWICE,
+  ONCE_LEFT
 } ctrs_srs;
 
-typedef enum 
+typedef enum
 {
   DOWN,
   RIGHT,
@@ -52,14 +52,14 @@ typedef enum
   HARD_DROP
 } ctrs_dir;
 
-typedef struct 
+typedef struct
 {
   ctrs_vec2 pos;
   ctrs_matrix m;
   ctrs_mino_type t;
   ctrs_srs r;
 
-  bool locked; 
+  bool locked;
   bool held;
 
   unsigned long lock_tick;
@@ -68,7 +68,7 @@ typedef struct
   char ghost_y;
 } ctrs_mino;
 
-typedef struct 
+typedef struct
 {
   ctrs_vec2 pos;
   ctrs_matrix m;
@@ -79,7 +79,7 @@ typedef struct
 
 typedef struct ctrs_game ctrs_game;
 
-typedef struct 
+typedef struct
 {
   unsigned long drop_period;
   unsigned long next_piece_delay;
@@ -88,10 +88,10 @@ typedef struct
   unsigned long force_lock;
 
 #if CETRIS_ENABLE_DAS
-  unsigned long das_arr; 
+  unsigned long das_arr;
   unsigned long das_das;
 #endif
-  
+
   unsigned char board_x;
   unsigned char board_y;
   unsigned char board_visible;
@@ -185,11 +185,11 @@ struct ctrs_game {
 
 const ctrs_matrix ctrs_default_matrices[7] =
 {
-  { 0b0000, 0b1100, 0b0110, 0b0000}, 
+  { 0b0000, 0b1100, 0b0110, 0b0000},
   { 0b0000, 0b0010, 0b1110, 0b0000},
-  { 0b0000, 0b0110, 0b0110, 0b0000}, 
+  { 0b0000, 0b0110, 0b0110, 0b0000},
   { 0b0000, 0b0110, 0b1100, 0b0000},
-  { 0b0000, 0b1111, 0b0000, 0b0000}, 
+  { 0b0000, 0b1111, 0b0000, 0b0000},
   { 0b0000, 0b1000, 0b1110, 0b0000},
   { 0b0000, 0b0100, 0b1110, 0b0000}
 };
@@ -218,12 +218,12 @@ static const ctrs_vec2 srs_wall_kicks_i[8][5] = {
 };
 
 static const ctrs_vec2 basic_movements[3] = {
-    {0, 1}, {1, 0}, {-1, 0} // DOWN, RIGHT, LEFT
+  {0, 1}, {1, 0}, {-1, 0} // DOWN, RIGHT, LEFT
 };
 
 static void update_board(ctrs_game *g);
 
-static void 
+static void
 set_piece(ctrs_game *g, unsigned char type, ctrs_mino* mino)
 {
   memset(mino, 0, sizeof(ctrs_mino));
@@ -240,11 +240,11 @@ set_piece(ctrs_game *g, unsigned char type, ctrs_mino* mino)
   if (type == MINO_I) mino->pos.y++;
 }
 
-static inline void 
+static inline void
 shuffle_queue(ctrs_game *g)
 {
   unsigned char i, r, t;
-  for (i = 0; i < 7; i++) 
+  for (i = 0; i < 7; i++)
   {
     r = rand() % 7;
     t = g->next_queue[i];
@@ -254,24 +254,26 @@ shuffle_queue(ctrs_game *g)
   }
 }
 
-static inline int 
-check_matrix(ctrs_game *g, ctrs_matrix *m) 
+static inline int
+check_matrix(ctrs_game *g, ctrs_matrix *m)
 {
   ctrs_vec2 r;
 
   for (int j = 0; j < 4; j++)
-  for (int s = 0; s < 4; s++)
   {
-    r = (ctrs_vec2){j + g->current.pos.x, s + g->current.pos.y};
-    if (r.y < 0) continue;
-    if (((*m)[s]>>(3 - j))&1)
+    for (int s = 0; s < 4; s++)
     {
-      if (r.x >= g->config.board_x || r.x < 0)
-        return 0;
-      if (r.y >= g->config.board_y)
-        return -1;
-      if (g->board[r.x][r.y] & CTRS_SLOT_OCCUPIED)
-        return -1;
+      r = (ctrs_vec2){j + g->current.pos.x, s + g->current.pos.y};
+      if (r.y < 0) continue;
+      if (((*m)[s]>>(3 - j))&1)
+      {
+        if (r.x >= g->config.board_x || r.x < 0)
+          return 0;
+        if (r.y >= g->config.board_y)
+          return -1;
+        if (g->board[(unsigned char)r.x][(unsigned char)r.y] & CTRS_SLOT_OCCUPIED)
+          return -1;
+      }
     }
   }
 
@@ -279,82 +281,82 @@ check_matrix(ctrs_game *g, ctrs_matrix *m)
 }
 
 // TODO: hard score
-static void 
-add_score(ctrs_game *g, int lines) 
+static void
+add_score(ctrs_game *g, int lines)
 {
-  if (!g->tspin && !g->mini_tspin) 
+  if (!g->tspin && !g->mini_tspin)
   {
-    switch (lines) 
+    switch (lines)
     {
-      case 1:
-        g->score += 100 * g->level;
-        break;
-      case 2:
-        g->score += 300 * g->level;
-        break;
-      case 3:
-        g->score += 500 * g->level;
-        break;
-      case 4:
-        g->score += 800 * g->level;
-        break;
+    case 1:
+      g->score += 100 * g->level;
+      break;
+    case 2:
+      g->score += 300 * g->level;
+      break;
+    case 3:
+      g->score += 500 * g->level;
+      break;
+    case 4:
+      g->score += 800 * g->level;
+      break;
     }
   }
-  else if (g->tspin) 
+  else if (g->tspin)
   {
     switch (lines)
     {
-      case 0:
-        g->score += 400 * g->level;
-        break;
-      case 1:
-        g->score += 800 * g->level;
-        break;
-      case 2:
-        g->score += 1200 * g->level;
-        break;
-      case 3:
-        g->score += 1600 * g->level;
-        break;
+    case 0:
+      g->score += 400 * g->level;
+      break;
+    case 1:
+      g->score += 800 * g->level;
+      break;
+    case 2:
+      g->score += 1200 * g->level;
+      break;
+    case 3:
+      g->score += 1600 * g->level;
+      break;
     }
     g->tspin = false;
-  } 
-  else if (g->mini_tspin) 
+  }
+  else if (g->mini_tspin)
   {
     switch (lines)
     {
-      case 0:
-        g->score += 100 * g->level;
-        break;
-      case 1:
-        g->score += 200 * g->level;
-        break;
-      case 2:
-        g->score += 400 * g->level;
-        break;
-      }
+    case 0:
+      g->score += 100 * g->level;
+      break;
+    case 1:
+      g->score += 200 * g->level;
+      break;
+    case 2:
+      g->score += 400 * g->level;
+      break;
+    }
     g->mini_tspin = false;
   }
 }
 
-static void 
-make_ghosts(ctrs_game *g) 
+static void
+make_ghosts(ctrs_game *g)
 {
   int orig_y = g->current.pos.y;
 
-  while (check_matrix(g, &g->current.m) > 0) 
+  while (check_matrix(g, &g->current.m) > 0)
     g->current.pos.y++;
 
   if (g->current.pos.y == orig_y)
     g->current.ghost_y = orig_y;
-  else 
+  else
     g->current.ghost_y = g->current.pos.y - 1;
- 
+
   g->current.pos.y = orig_y;
 }
 
-static void 
-move_current(ctrs_game *g, unsigned char move) 
+static void
+move_current(ctrs_game *g, unsigned char move)
 {
   if (g->game_over || g->next_piece_tick)
     return;
@@ -368,18 +370,18 @@ move_current(ctrs_game *g, unsigned char move)
     g->current.pos.y -= basic_movements[move].y;
     g->current.pos.x -= basic_movements[move].x;
 
-    if (move == DOWN && check == -1) 
+    if (move == DOWN && check == -1)
     {
       if (!g->current.force_lock_tick && g->config.force_lock)
         g->current.force_lock_tick = g->tick + g->config.force_lock;
       if (!g->current.lock_tick)
         g->current.lock_tick = g->tick + g->config.lock_delay;
     }
-  } 
-  else 
+  }
+  else
   {
     g->events.move_event++;
-    if (g->current.lock_tick) 
+    if (g->current.lock_tick)
       g->current.lock_tick = g->tick + g->config.lock_delay;
     if (move == DOWN && g->held_moves[DOWN])
       g->score++;
@@ -388,7 +390,7 @@ move_current(ctrs_game *g, unsigned char move)
   update_board(g);
 }
 
-static void 
+static void
 next_piece(ctrs_game *g)
 {
   g->next_drop_tick = 0;
@@ -396,17 +398,17 @@ next_piece(ctrs_game *g)
 
   set_piece(g, g->piece_queue[g->current_index], &g->current);
 
-  if (check_matrix(g, &g->current.m) <= 0) 
+  if (check_matrix(g, &g->current.m) <= 0)
   {
     g->game_over = true;
     g->events.stop_game = 1;
   }
 
-  if (!g->game_over) 
+  if (!g->game_over)
     move_current(g, DOWN);
-  
+
   g->current_index++;
-  if (g->current_index == 7) 
+  if (g->current_index == 7)
   {
     g->current_index = 0;
 
@@ -417,16 +419,18 @@ next_piece(ctrs_game *g)
   update_board(g);
 }
 
-static void 
-lock_current(ctrs_game *g) 
+static void
+lock_current(ctrs_game *g)
 {
   for (int j = 0; j < 4; j++)
-  for (int s = 0; s < 4; s++)
   {
-    if ((g->current.m[s]>>(3 - j))&1) 
+    for (int s = 0; s < 4; s++)
     {
-      g->board[g->current.pos.x + j][g->current.pos.y + s] |= CTRS_SLOT_OCCUPIED;
-      g->board[g->current.pos.x + j][g->current.pos.y + s] |= g->current.t << 5;
+      if ((g->current.m[s]>>(3 - j))&1)
+      {
+        g->board[g->current.pos.x + j][g->current.pos.y + s] |= CTRS_SLOT_OCCUPIED;
+        g->board[g->current.pos.x + j][g->current.pos.y + s] |= g->current.t << 5;
+      }
     }
   }
 
@@ -443,14 +447,14 @@ lock_current(ctrs_game *g)
   update_board(g);
 }
 
-static void 
-hard_drop(ctrs_game *g) 
+static void
+hard_drop(ctrs_game *g)
 {
   if (g->game_over || g->next_piece_tick)
     return;
 
   int drop_count = 0;
-  while (check_matrix(g, &g->current.m) > 0) 
+  while (check_matrix(g, &g->current.m) > 0)
   {
     g->current.pos.y++;
     drop_count++;
@@ -464,41 +468,43 @@ hard_drop(ctrs_game *g)
   lock_current(g);
 }
 
-static inline void 
-rotate_matrix(ctrs_game *g, ctrs_matrix *m, bool clockwise) 
+static inline void
+rotate_matrix(ctrs_game *g, ctrs_matrix *m, bool clockwise)
 {
   for (int j = 0; j < 4; j++)
-  for (int s = 0; s < 4; s++)
   {
-    if ((g->current.m[s]>>(3 - j))&1) 
+    for (int s = 0; s < 4; s++)
     {
-      unsigned char new_x = (clockwise) ? 1 - (s - 2) : 1 + (s - 2);
-      unsigned char new_y = (clockwise) ? 2 + (j - 1) : 2 - (j - 1);
+      if ((g->current.m[s]>>(3 - j))&1)
+      {
+        unsigned char new_x = (clockwise) ? 1 - (s - 2) : 1 + (s - 2);
+        unsigned char new_y = (clockwise) ? 2 + (j - 1) : 2 - (j - 1);
+
+        if (g->current.t == MINO_I)
+          clockwise ? new_y-- : new_x++;
 
-      if (g->current.t == MINO_I) 
-        clockwise ? new_y-- : new_x++;
-      
-      (*m)[new_y] |= (unsigned char)0b1000 >> (new_x);
+        (*m)[new_y] |= (unsigned char)0b1000 >> (new_x);
+      }
     }
   }
 }
 
-static void 
-rotate_piece(ctrs_game *g, bool clockwise) 
+static void
+rotate_piece(ctrs_game *g, bool clockwise)
 {
   if (g->game_over || g->next_piece_tick)
     return;
-  
+
   if (g->current.t == MINO_O)
     return;
-  
+
   unsigned char next = 0, wall_kick = 0;
-  if (clockwise) 
+  if (clockwise)
   {
     next = (g->current.r + 1) % 4;
     wall_kick = g->current.r * 2;
-  } 
-  else 
+  }
+  else
   {
     next = ((g->current.r - 1) + 4) % 4;
     wall_kick = (next * 2) + 1;
@@ -513,15 +519,15 @@ rotate_piece(ctrs_game *g, bool clockwise)
   bool set_current = false, did_kick = false;
   for (int i = 0; i < 4; i++)
   {
-    if (g->current.t == MINO_I) 
+    if (g->current.t == MINO_I)
       kick = srs_wall_kicks_i[wall_kick][i];
-    else 
+    else
       kick = srs_wall_kicks[wall_kick][i];
 
     g->current.pos.x += kick.x;
     g->current.pos.y -= kick.y;
 
-    if (check_matrix(g, &m) > 0) 
+    if (check_matrix(g, &m) > 0)
     {
       set_current = true;
       if (i > 0) did_kick = true;
@@ -532,13 +538,13 @@ rotate_piece(ctrs_game *g, bool clockwise)
     g->current.pos.y += kick.y;
   }
 
-  if (set_current) 
+  if (set_current)
   {
     /* check for tspin */
-    if (g->current.t == MINO_T) 
+    if (g->current.t == MINO_T)
     {
       bool did_tspin = true;
-      for (int i = 1; i < 3; i++) 
+      for (int i = 1; i < 3; i++)
       {
         g->current.pos.x += basic_movements[i].x;
         g->current.pos.y += basic_movements[i].y;
@@ -550,7 +556,7 @@ rotate_piece(ctrs_game *g, bool clockwise)
         g->current.pos.y -= basic_movements[i].y;
       }
 
-      if (did_tspin) 
+      if (did_tspin)
       {
         if (did_kick) g->mini_tspin = true;
         else g->tspin = true;
@@ -566,72 +572,74 @@ rotate_piece(ctrs_game *g, bool clockwise)
   }
 }
 
-static inline void 
-clear_line(ctrs_game *g, int y) 
+static inline void
+clear_line(ctrs_game *g, int y)
 {
   for (int s = y - 1; s >= 0; s--)
-  for (int x = 0; x < g->config.board_x; x++) 
-    g->board[x][s + 1] = g->board[x][s];
+  {
+    for (int x = 0; x < g->config.board_x; x++)
+      g->board[x][s + 1] = g->board[x][s];
+  }
 }
 
-static void 
+static void
 update_board(ctrs_game *g)
 {
   if (g->game_over)
     return;
 
   int lines_cleared = 0;
-  for (int y = g->highest_line; y < g->config.board_y; y++) 
+  for (int y = g->highest_line; y < g->config.board_y; y++)
   {
     bool should_clear_line = true;
-    for (int x = 0; x < g->config.board_x; x++) 
+    for (int x = 0; x < g->config.board_x; x++)
     {
-      if (!(g->board[x][y] & CTRS_SLOT_OCCUPIED) 
-          || g->line_remove_tick[y] > 0) 
+      if (!(g->board[x][y] & CTRS_SLOT_OCCUPIED)
+          || g->line_remove_tick[y] > 0)
         should_clear_line = false;
     }
 
-    if (g->config.wait_on_clear) 
+    if (g->config.wait_on_clear)
     {
       // remove tick only tracked on first block of line
-      if (g->line_remove_tick[y] && g->line_remove_tick[y] <= g->tick) 
+      if (g->line_remove_tick[y] && g->line_remove_tick[y] <= g->tick)
       {
         g->line_remove_tick[y] = 0;
         clear_line(g, y);
       }
-      if (should_clear_line) 
+      if (should_clear_line)
       {
         g->line_remove_tick[y] = g->tick + g->config.line_delay_clear;
         lines_cleared++;
       }
-    } 
+    }
     else if (should_clear_line)
     {
-      clear_line(g, y); 
+      clear_line(g, y);
       lines_cleared++;
     }
   }
 
   make_ghosts(g);
 
-  if (g->current.locked && !g->next_piece_tick) 
+  if (g->current.locked && !g->next_piece_tick)
   {
-    if (lines_cleared > 0) 
+    if (lines_cleared > 0)
       g->next_piece_tick = g->tick + g->config.next_piece_delay;
-    else 
+    else
     {
       next_piece(g);
       g->line_combo = 0;
     }
   }
-  
-  if (g->tspin || g->mini_tspin) 
+
+  if (g->tspin || g->mini_tspin)
     add_score(g, lines_cleared);
-  else if (lines_cleared > 0) 
+  else if (lines_cleared > 0)
     add_score(g, lines_cleared);
 
   g->lines += lines_cleared;
-  if (lines_cleared > 0) 
+  if (lines_cleared > 0)
   {
     g->events.line_event = lines_cleared;
     if (lines_cleared == 4)
@@ -644,11 +652,11 @@ update_board(ctrs_game *g)
   if (g->lines >= (g->level * 10)) g->level++;
 }
 
-void 
-ctrs_hold_piece(ctrs_game *g) 
+void
+ctrs_hold_piece(ctrs_game *g)
 {
   if (g->current.held) return;
-  if (g->piece_held) 
+  if (g->piece_held)
   {
     unsigned char tmp = g->current.t;
     g->current = g->held;
@@ -668,24 +676,24 @@ ctrs_hold_piece(ctrs_game *g)
 }
 
 #if CETRIS_ENABLE_DAS
-void 
+void
 ctrs_unhold_move(ctrs_game* g, unsigned char move)
 {
   if (!g->held_moves[move]) return;
 
   if (g->das_move == move)
   {
-    if (move == LEFT && g->held_moves[RIGHT]) 
+    if (move == LEFT && g->held_moves[RIGHT])
     {
       g->das_move = RIGHT;
       g->das_wait = g->tick + g->config.das_das;
-    } 
+    }
     else if (move == RIGHT && g->held_moves[LEFT])
     {
       g->das_move = LEFT;
       g->das_wait = g->tick + g->config.das_das;
-    } 
-    else 
+    }
+    else
       g->das_wait = 0;
 
     g->next_das_move = 0;
@@ -698,17 +706,17 @@ ctrs_unhold_move(ctrs_game* g, unsigned char move)
 }
 #endif
 
-void 
-ctrs_move_piece(ctrs_game *g, unsigned char move) 
+void
+ctrs_move_piece(ctrs_game *g, unsigned char move)
 {
 #if CETRIS_ENABLE_DAS
   if (g->held_moves[move]) return;
-  if (move == LEFT || move == RIGHT) 
+  if (move == LEFT || move == RIGHT)
   {
-    if ((move != g->das_move) || !g->das_wait) 
+    if ((move != g->das_move) || !g->das_wait)
     {
       g->das_move = move;
-      if (!g->waiting) 
+      if (!g->waiting)
       {
         g->das_wait = g->tick + g->config.das_das;
         g->next_das_move = 0;
@@ -722,29 +730,29 @@ ctrs_move_piece(ctrs_game *g, unsigned char move)
 
   g->held_moves[move] = 1;
 #endif
-  
+
   if (g->waiting) return;
 
-  switch (move) 
+  switch (move)
   {
-    case LEFT:
-    case RIGHT:
-    case DOWN:
-      move_current(g, move);
-      break;
-    case HARD_DROP:
-      hard_drop(g);
-      break;
-    case ROTATE_CW:
-      rotate_piece(g, 1);
-      break;
-    case ROTATE_CCW:
-      rotate_piece(g, 0);
-      break;
+  case LEFT:
+  case RIGHT:
+  case DOWN:
+    move_current(g, move);
+    break;
+  case HARD_DROP:
+    hard_drop(g);
+    break;
+  case ROTATE_CW:
+    rotate_piece(g, 1);
+    break;
+  case ROTATE_CCW:
+    rotate_piece(g, 0);
+    break;
   }
 }
 
-void 
+void
 ctrs_init_game(ctrs_game *g)
 {
   srand(time(NULL));
@@ -759,7 +767,7 @@ ctrs_init_game(ctrs_game *g)
   memset(g, 0, sizeof(ctrs_game) - sizeof(ctrs_config));
 
   g->board = (unsigned char **)calloc(g->config.board_x, sizeof(unsigned char *));
-  for (int i = 0; i < g->config.board_x; i++) 
+  for (int i = 0; i < g->config.board_x; i++)
     g->board[i] = (unsigned char *)calloc(g->config.board_y, sizeof(unsigned char));
 
   g->line_remove_tick = (unsigned long *)calloc(g->config.board_y, sizeof(unsigned long));
@@ -779,7 +787,7 @@ ctrs_init_game(ctrs_game *g)
   next_piece(g);
 }
 
-bool 
+bool
 ctrs_update_game_tick(ctrs_game *g)
 {
   if (g->game_over)
@@ -792,31 +800,31 @@ ctrs_update_game_tick(ctrs_game *g)
     return true;
 
   bool did_move = false;
-  if (g->next_drop_tick && g->tick >= g->next_drop_tick) 
+  if (g->next_drop_tick && g->tick >= g->next_drop_tick)
   {
     move_current(g, DOWN);
     g->next_drop_tick = 0;
     did_move = true;
   }
 
-  if (!g->next_drop_tick) 
+  if (!g->next_drop_tick)
   {
-    if (g->held_moves[DOWN]) 
+    if (g->held_moves[DOWN])
     {
       g->next_drop_tick = g->tick + g->config.drop_period;
     }
-    else 
+    else
     {
-      if (g->level <= 20) 
+      if (g->level <= 20)
         g->next_drop_tick = g->tick + g->config.levels[g->level - 1];
-      else 
+      else
         g->next_drop_tick = g->tick + g->config.levels[19];
     }
   }
 
   /* lock piece if it was hovering for CETRIS_LOCK_DELAY */
-  if (((g->current.lock_tick && g->current.lock_tick <= g->tick) 
-	|| (g->current.force_lock_tick && g->current.force_lock_tick <= g->tick))) 
+  if (((g->current.lock_tick && g->current.lock_tick <= g->tick)
+      || (g->current.force_lock_tick && g->current.force_lock_tick <= g->tick)))
   {
     g->current.pos.y++;
     char res = check_matrix(g, &g->current.m);
@@ -832,14 +840,14 @@ ctrs_update_game_tick(ctrs_game *g)
   }
 
 #if CETRIS_ENABLE_DAS
-  if ((g->next_das_move && g->tick >= g->next_das_move) || g->next_das_move == 1) 
+  if ((g->next_das_move && g->tick >= g->next_das_move) || g->next_das_move == 1)
   {
-    if (!g->waiting) 
+    if (!g->waiting)
       move_current(g, g->das_move);
 
     g->next_das_move = g->tick + g->config.das_arr;
   }
-  else if (!g->next_das_move && g->das_wait && g->tick >= g->das_wait) 
+  else if (!g->next_das_move && g->das_wait && g->tick >= g->das_wait)
     g->next_das_move = g->tick + g->config.das_arr;
 #endif
 
diff --git a/lib/meson.build b/lib/meson.build
deleted file mode 100755
index eb2e989..0000000
--- a/lib/meson.build
+++ /dev/null
@@ -1,10 +0,0 @@
-src = ['cetris.c', 'rules.c']
-src += is_windows ? 'timer_windows.c' : 'timer_linux.c'
-
-threads = dependency('threads')
-
-cetris_lib = static_library('cetris', src, dependencies: threads,
-   include_directories: cetris_inc, install: false)
-
-cetris = declare_dependency(include_directories: cetris_inc,
-   link_with: cetris_lib)
diff --git a/lib/rules.h b/lib/rules.h
index ed68d54..c18104e 100755
--- a/lib/rules.h
+++ b/lib/rules.h
@@ -3,23 +3,23 @@
 
 #include "cetris.h"
 
-bool twenty_line_sprint(ctrs_game *g) 
+bool twenty_line_sprint(ctrs_game *g)
 {
   return g->lines >= 20;
 }
 
-bool forty_line_sprint(ctrs_game *g) 
+bool forty_line_sprint(ctrs_game *g)
 {
   return g->lines >= 40;
 }
 
-bool marathon(ctrs_game *g) 
+bool marathon(ctrs_game *g)
 {
   return false;
 }
 
 // https://tetris.fandom.com/wiki/Tetris_Worlds
-unsigned long tetris_worlds_levels[20] = 
+unsigned long tetris_worlds_levels[20] =
 {
   1000, 793, 618, 473, 355, 262, 189, 134, 94, 64,
   43,   28,  18,  11,  7,   4,   2,   1,   1,  1
diff --git a/lib/test.h b/lib/test.h
index 67f6388..67f6388 100755..100644
--- a/lib/test.h
+++ b/lib/test.h