Timer for new fruit and player updating

Instead of changing the FPS we'll manage it ourselves and keep a
constant 60fps.

src/main.cpp

@@ -293,51 +293,82 @@ struct Time
 using Clock = chrono::steady_clock;
 int main(void)
 {
-  constexpr size_t X = 50, Y = 50;
+  srand(time(NULL));
+  constexpr size_t X = 10, Y = 10;
   State<X, Y> state;
-  state.player.points.push_back({15, 15});
+  state.reset();
-  for (size_t i = 0; i < X; ++i)
+
-    for (size_t j = 0; j < Y; ++j)
+  InitWindow(WIDTH, HEIGHT, "snek");
-      state.grid[i][j] = Type::FRUIT;
+  SetTargetFPS(60);
+
+  chrono::time_point<Clock> time_start{Clock::now()};
+  constexpr double max_score = 100;
+
+  constexpr double fruit_delta_max = 5;
+  constexpr double fruit_delta_min = 1;
+  constexpr auto fruit_delta       = [](size_t player_size)
+  {
+    return fruit_delta_min +
+           ((fruit_delta_max - fruit_delta_min) *
+            (1 - (player_size < max_score ? player_size / max_score : 1)));
+  };
+
+  chrono::time_point<Clock> fruit_cur{Clock::now()};
+  chrono::time_point<Clock> fruit_prev{Clock::now()};
+
+  constexpr double update_delta_max = 500;
+  constexpr double update_delta_min = 50;
+  constexpr auto update_delta       = [](size_t player_size)
+  {
+    return update_delta_min +
+           ((update_delta_max - update_delta_min) *
+            (1 - (player_size < max_score ? player_size / max_score : 1)));
+  };
+  chrono::time_point<Clock> update_cur{Clock::now()};
+  chrono::time_point<Clock> update_prev{Clock::now()};
 
   Direction dir = Direction::LEFT;
-  InitWindow(WIDTH, HEIGHT, "snek");
+  bool paused   = false;
-  int fps = 10;
-  SetTargetFPS(fps);
-
-  chrono::time_point<Clock> beg{Clock::now()};
   while (!WindowShouldClose())
   {
-    state.player_fruit_collision();
+    if (!paused)
+    {
+      if (IsKeyDown(KEY_J))
+        dir = Direction::DOWN;
+      else if (IsKeyDown(KEY_K))
+        dir = Direction::UP;
+      else if (IsKeyDown(KEY_H))
+        dir = Direction::LEFT;
+      else if (IsKeyDown(KEY_L))
+        dir = Direction::RIGHT;
 
-    if (IsKeyDown(KEY_J) && (Direction)(-((int)dir)) != Direction::DOWN)
+      update_cur = Clock::now();
-      dir = Direction::DOWN;
+      if (chrono::duration_cast<chrono::milliseconds>(update_cur - update_prev)
-    else if (IsKeyDown(KEY_K) && (Direction)(-((int)dir)) != Direction::UP)
+              .count() >= update_delta(state.player.points.size()))
-      dir = Direction::UP;
+      {
-    else if (IsKeyDown(KEY_H) && (Direction)(-((int)dir)) != Direction::LEFT)
+        update_prev = update_cur;
-      dir = Direction::LEFT;
+        if (!(state.player.points.size() > 1 &&
-    else if (IsKeyDown(KEY_L) && (Direction)(-((int)dir)) != Direction::RIGHT)
+              ((Point{dir} + (*state.player.points.begin())) ==
-      dir = Direction::RIGHT;
+               (*(state.player.points.begin() + 1)))))
-    else if (IsKeyDown(KEY_EQUAL))
+          state.player.dir = dir;
-    {
+        bool collide = state.update_player_head();
-      ++fps;
+        if (collide)
-      if (fps > 60)
+        {
-        fps = 60;
+          paused = false;
-      SetTargetFPS(fps);
+          // state.reset();
-    }
+          time_start = Clock::now();
-    else if (IsKeyDown(KEY_MINUS))
+        }
-    {
+        state.player_fruit_collision();
-      --fps;
+      }
-      if (fps < 0)
-        fps = 1;
-      SetTargetFPS(fps);
-    }
 
-    bool collide = state.update_player_head(dir);
+      fruit_cur = Clock::now();
-    if (collide)
+
-    {
+      if (chrono::duration_cast<chrono::seconds>(fruit_cur - fruit_prev)
-      state.reset();
+              .count() >= fruit_delta(state.player.points.size()))
-      beg = Clock::now();
+      {
+        fruit_prev = fruit_cur;
+        state.make_rand_fruit();
+      }
     }
 
     BeginDrawing();