mark visited and starting states

src/camera.cpp

@@ -1,8 +1,6 @@
 #include "camera.hpp"
 #include "config.hpp"
-#include "util.hpp"
 
-#include <iostream>
 #include <raylib.h>
 #include <raymath.h>
 
@@ -78,11 +76,10 @@ auto OrbitCamera3D::Update(const Vector3 &current_target) -> void {
   }
 
   if (target_lock) {
-    target_target = current_target;
     target = Vector3MoveTowards(
-        target, target_target,
+        target, current_target,
         CAMERA_SMOOTH_SPEED * GetFrameTime() *
-            Vector3Length(Vector3Subtract(target, target_target)));
+            Vector3Length(Vector3Subtract(target, current_target)));
   }
 
   distance = Clamp(distance, MIN_CAMERA_DISTANCE, MAX_CAMERA_DISTANCE);

src/main.cpp

@@ -23,8 +23,6 @@
 //       - Click states to display them in the board
 //       - Find shortest path to any winning state and mark it in the graph
 //         - Also mark the next move along the path on the board
-// TODO: Mark the starting state
-// TODO: Mark the visited states
 
 auto main(int argc, char *argv[]) -> int {
   // if (argc < 2) {
@@ -103,7 +101,8 @@ auto main(int argc, char *argv[]) -> int {
 
     renderer.UpdateTextureSizes();
     renderer.DrawMassSprings(mass_springs, state.current_state,
-                             state.winning_states);
+                             state.CurrentGenerator()(), state.winning_states,
+                             state.visited_states);
 
     renderer.DrawKlotski(state.current_state, input.hov_x, input.hov_y,
                          input.sel_x, input.sel_y, input.block_add_x,

src/renderer.cpp

@@ -63,7 +63,9 @@ auto Renderer::ReallocateGraphInstancingIfNecessary(
 
 auto Renderer::DrawMassSprings(const MassSpringSystem &mass_springs,
                                const State &current_state,
-                               const std::unordered_set<State> &winning_states)
+                               const State &starting_state,
+                               const std::unordered_set<State> &winning_states,
+                               const std::unordered_set<State> &visited_states)
     -> void {
   ZoneScoped;
 
@@ -124,6 +126,19 @@ auto Renderer::DrawMassSprings(const MassSpringSystem &mass_springs,
     }
   }
 
+  // Mark visited states
+  for (const auto &state : visited_states) {
+    const Mass &visited_mass = mass_springs.GetMass(state);
+
+    DrawCube(visited_mass.position, VERTEX_SIZE * 1.5, VERTEX_SIZE * 1.5,
+             VERTEX_SIZE * 1.5, PURPLE);
+  }
+
+  // Mark starting state
+  const Mass &starting_mass = mass_springs.GetMass(starting_state);
+  DrawCube(starting_mass.position, VERTEX_SIZE * 2, VERTEX_SIZE * 2,
+           VERTEX_SIZE * 2, ORANGE);
+
   // Mark current state
   const Mass &current_mass = mass_springs.GetMass(current_state);
   DrawCube(current_mass.position, VERTEX_SIZE * 2, VERTEX_SIZE * 2,

src/state.cpp

@@ -64,11 +64,13 @@ auto StateManager::UpdateGraph() -> void {
     if (win_conditions[current_preset](current_state)) {
       winning_states.insert(current_state);
     }
+    visited_states.insert(current_state);
   }
 }
 
 auto StateManager::ClearGraph() -> void {
   winning_states.clear();
+  visited_states.clear();
   mass_springs.Clear();
   mass_springs.AddMass(MASS, false, current_state);
 
@@ -88,6 +90,10 @@ auto StateManager::FindWinningStates() -> void {
             << std::endl;
 }
 
+auto StateManager::CurrentGenerator() -> StateGenerator {
+  return generators[current_preset];
+}
+
 auto StateManager::CurrentWinCondition() -> WinCondition {
   return win_conditions[current_preset];
 }