Predictable Algo done

Assets/Scripts/ProtoTyping/AlgorithmTest.cs

@@ -7,15 +7,29 @@ public class AlgorithmTest : MonoBehaviour
     public List<float> allHits = new List<float>();
     public LineRenderer line;
     public Vector2 offsetMultipliers = Vector2.one;
-    
+    public GameObject objectToMove; // The GameObject to move
+
+    private Vector3[] points;
+
+
+    public bool MoveCmd;
+
+
+    Coroutine movingCoroutine;
     void OnDrawGizmos(){
         RegenerateLines();
+
+        if(MoveCmd){
+            MoveCmd = false;
+            if(movingCoroutine!= null){StopCoroutine(movingCoroutine);}
+            movingCoroutine = StartCoroutine(MoveAlongPath());
+        }
     }
 
     void RegenerateLines(){
-        Vector3[] points = new Vector3[allHits.Count];
+        points = new Vector3[allHits.Count];
 
-        for(int i=0; i < points.Length; i++){
+        for (int i = 0; i < points.Length; i++) {
             points[i] = GetPosition(i);
         }
 
@@ -32,7 +46,7 @@ public class AlgorithmTest : MonoBehaviour
         // Calculate diff and prevY if the index is greater than 0
         if (index > 0) {
             diff = allHits[index] - allHits[index - 1];
-            prevY = GetPosition(index - 1).y; // Recursively get the previous Y value
+            prevY = points[index - 1].y; // Use the already calculated point to avoid recursion
         }
 
         float flipSide = index % 2 == 0 ? 1 : -1;
@@ -41,4 +55,68 @@ public class AlgorithmTest : MonoBehaviour
         return new Vector3(hitX * offsetMultipliers.x, y, 0);
     }
 
+    // Call this function to start moving the GameObject along the path
+    public void StartMovement() {
+        if (objectToMove != null && points != null && points.Length > 1) {
+            StartCoroutine(MoveAlongPath());
+        }
+    }
+
+    private IEnumerator MoveAlongPath() {
+        float timer=0;
+        while(timer < allHits[allHits.Count-1]){
+            timer +=Time.deltaTime;
+            yield return null;
+            objectToMove.transform.position = GetPositionAtTime(timer);
+        }
+        // for (int i = 0; i < allHits.Count - 1; i++) {
+        //     Vector3 startPoint = points[i];
+        //     Vector3 endPoint = points[i + 1];
+        //     float duration = allHits[i + 1] - allHits[i];
+
+        //     yield return StartCoroutine(MoveFromTo(objectToMove, startPoint, endPoint, duration));
+        // }
+    }
+
+    private IEnumerator MoveFromTo(GameObject obj, Vector3 start, Vector3 end, float duration) {
+        float elapsedTime = 0;
+
+        while (elapsedTime < duration) {
+            obj.transform.position = Vector3.Lerp(start, end, elapsedTime / duration);
+            elapsedTime += Time.deltaTime;
+            yield return null;
+        }
+
+        obj.transform.position = end;
+    }
+    public Vector3 GetPositionAtTime(float time) {
+    if (points == null || points.Length < 2) {
+        return Vector3.zero; // Return zero if points are not set up
+    }
+
+    // If the time is before the first hit, return the first position
+    if (time <= allHits[0]) {
+        return points[0];
+    }
+
+    // If the time is after the last hit, return the last position
+    if (time >= allHits[allHits.Count - 1]) {
+        return points[points.Length - 1];
+    }
+
+    // Find the current segment based on the given time
+    for (int i = 0; i < allHits.Count - 1; i++) {
+        if (time >= allHits[i] && time < allHits[i + 1]) {
+            Vector3 startPoint = points[i];
+            Vector3 endPoint = points[i + 1];
+            float segmentDuration = allHits[i + 1] - allHits[i];
+            float t = (time - allHits[i]) / segmentDuration;
+
+            return Vector3.Lerp(startPoint, endPoint, t);
+        }
+    }
+
+    return Vector3.zero; // Return zero if no valid segment is found (should not happen)
+}
+
 }