Enable Double Click movement, trajectory WIP

Assets/Scenes/Test.unity

@@ -1012,7 +1012,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 0bf826b8a4774ba4b9c6a1cff6925667, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  alpha: {x: 0.1, y: 0, z: 0}
+  alpha: {x: 0, y: 0, z: 0}
   v: {x: 0, y: 0, z: 0}
   orientation: {x: 0, y: 0, z: 0}
   levelManager: {fileID: 279236944}
@@ -1320,7 +1320,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 9cbe363fdf02257478cb799cdf2190b3, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  alpha: {x: 0.1, y: 0, z: 0}
+  alpha: {x: 0, y: 0, z: 0}
   v: {x: 0, y: 0, z: 0}
   orientation: {x: 0, y: 0, z: 0}
   levelManager: {fileID: 279236944}
@@ -2545,7 +2545,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 0bf826b8a4774ba4b9c6a1cff6925667, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  alpha: {x: 0.1, y: 0, z: 0}
+  alpha: {x: 0, y: 0, z: 0}
   v: {x: 0, y: 0, z: 0}
   orientation: {x: 0, y: 0, z: 0}
   levelManager: {fileID: 279236944}

Assets/Scripts/BackgroundMovement.cs

@@ -40,7 +40,7 @@ public class BackgroundMovement : MonoBehaviour
     // Start is called before the first frame update
     void Start()
     {
-        toggle = false;
+        toggle = true;
         v = new Vector3(0, 0, 0);
     }
 

Assets/Scripts/Constants.cs

@@ -7,6 +7,7 @@ using MathNet.Numerics.LinearAlgebra.Double;
 public static class Constants
 {
     public static double c => 4; // speed of light.
+    public static int alphatinterval => 50;
     public static double Gamma(double v)
     {
         return 1.0f / Mathf.Sqrt((float)(1 - ((v / c) * (v / c))));

Assets/Scripts/FlatlandMovement.cs

@@ -10,12 +10,14 @@ public class FlatlandMovement : MonoBehaviour
     protected bool grabbed = false;
 
     protected int cnt = 0;
-    protected double beta = 0.5f; // v/c
+
+    [SerializeField]
+    protected double beta = 0.0f; // v/c
 
     protected MatrixBuilder<double> M = Matrix<double>.Build;
     protected VectorBuilder<double> V = Vector<double>.Build;
 
-    public Vector3 alpha = new Vector3(0.1f, 0.0f, 0.0f); // proper acceleration
+    public Vector3 alpha = new Vector3(0.0f, 0.0f, 0.0f); // proper acceleration
     public Vector3 v;
     public Vector3 orientation;
 
@@ -152,9 +154,60 @@ public class FlatlandMovement : MonoBehaviour
     /// <returns></returns>
     public bool MoveInfinitelyToAbPosition(Vector3 dest, float v)
     {
-        isAutoMove = false;
-        isPatrol = true;
-        return SetVelecityToAbPosition(dest,v);
+        StartCoroutine(_AcceleratetoConstantVelocity(dest, v));
+        return true;
+    }
+
+    public IEnumerator _AcceleratetoConstantVelocity(Vector3 dest, float v)
+    {
+        Vector3 acceleration = new Vector3(dest.x, 0f, dest.y);
+        var tinterval = Constants.alphatinterval;
+
+        acceleration = acceleration.normalized;
+
+        var deltat = Time.fixedDeltaTime * tinterval;
+
+        acceleration = (float)((Constants.c / deltat) * MathNet.Numerics.Trig.Asinh(v * Constants.Gamma(v * Constants.c))) * acceleration;
+        // acceleration required to accelerate to v in deltat seconds: see https://en.wikiversity.org/wiki/Theory_of_relativity/Rindler_coordinates
+
+        var startv = levelManager.player.v;
+
+        levelManager.player.alpha = acceleration;
+
+        for(var j = 0; j < tinterval; ++j)
+        {
+            yield return new WaitForFixedUpdate();
+        }
+        levelManager.player.alpha = new Vector3(0, 0, 0);
+
+        var atmp = (float)(v * Constants.c);
+
+        double[] vtmp = { ((acceleration.x / acceleration.magnitude)), 0.0, ((acceleration.z / acceleration.magnitude)) };
+        var deltavnaive = V.DenseOfArray(vtmp);
+
+        double[] tmp = {Constants.c * Constants.Gamma(deltavnaive.L2Norm()),
+                      deltavnaive[0] * Constants.Gamma(deltavnaive.L2Norm()),
+                      deltavnaive[2] * Constants.Gamma(deltavnaive.L2Norm())};
+
+        var deltav = V.DenseOfArray(tmp);
+
+
+        if (startv.magnitude > 0.0f)
+        {
+            deltav = Constants.BoostMatrix(startv) * deltav;
+            deltav.Normalize(2);
+            deltav = deltav * atmp;
+
+            var deltavsize = Mathf.Sqrt((float)(deltav[1] * deltav[1] + deltav[2] * deltav[2]));
+        }
+
+        var tt = deltav[0] / Constants.c;
+
+        Vector3 finaldeltav = new Vector3((float)(deltav[1] / tt), 0.0f, (float)(deltav[2] / tt));
+
+        levelManager.player.v = finaldeltav;*/
+
+
     }
 
     public bool SetVelecityToAbPosition(Vector3 dest, float v)

Assets/Scripts/LogScaleSlider.cs

@@ -29,7 +29,7 @@ public class LogScaleSlider : MonoBehaviour
 
     public void UpdateValuebyVelocity(float v)
     {
-        slider.value = Mathf.Log10(1 - v) * -0.2f;
+        slider.value = Mathf.Log10(1 - v) * -(1.0f/5.0f);
     }
 
 }

Assets/Scripts/PathRenderer.cs

@@ -195,11 +195,41 @@ public class PathRenderer : MonoBehaviour
     public IEnumerator _StartMovingPath(int finalPathNum)
     {
         int i = 0;
-        while(i < finalPathNum)
+        var u = levelManager.player.v;
+        int tinterval = Constants.alphatinterval;
+
+        while (i <= finalPathNum)
         {
-            
+            Vector3 acceleration = new Vector3(square.GetNthPath(i).x,0f, square.GetNthPath(i).y);
+
+            acceleration.Normalize();
+
+            var deltat = Time.fixedDeltaTime * tinterval;
+
+            var v = square.GetPathVelocity(i) * Constants.c;
+
+
+            acceleration = (float)(v * Constants.Gamma(v) / deltat) * acceleration;
+
+            levelManager.player.alpha = acceleration;
+
+            for (var j = 0; j < tinterval; ++j)
+            {
+                yield return new WaitForFixedUpdate();
+            }
+
+            levelManager.player.alpha = new Vector3(0, 0, 0);
+
+            for (var j = 0; j < 1000; ++j)
+            {
+                yield return new WaitForFixedUpdate();
+            }
+
+            Background.Toggle = true;
+
+            break;
 
-            yield return new WaitForFixedUpdate();
+            i++;
         }
     }
 }

Assets/Scripts/Planemovement.cs

@@ -43,12 +43,36 @@ public class Planemovement : FlatlandMovement
             cnt = 0;
         }
 
-        alpha = 4 * Vector3.forward * Mathf.Cos(2 * Mathf.PI * cnt / 480) + 4 * Vector3.left * Mathf.Sin(2 * Mathf.PI * cnt / 480);
+        //alpha = 4 * Vector3.forward * Mathf.Cos(2 * Mathf.PI * cnt / 480) + 4 * Vector3.left * Mathf.Sin(2 * Mathf.PI * cnt / 480);
+
+        if ((levelManager.player.transform.position - transform.position).magnitude < 1f)
+        {
+            toggle = true;
+        }
+        else
+        {
+            toggle = false;
+        }
+
+        if (toggle && Input.GetKeyDown("g"))
+        {
+            grabbed = !grabbed;
+        }
+
+        if (grabbed)
+        {
+            v = levelManager.player.v;
+            Debug.Log("being grabbed");
+        }
 
         if (alpha.magnitude > 0.0f)
         {
 
-            var atmp = alpha.magnitude * Time.fixedDeltaTime;
+            var dt = (Constants.c / alpha.magnitude) * MathNet.Numerics.Trig.Sinh(alpha.magnitude * Time.fixedDeltaTime / Constants.c);
+            var atmp = (alpha.magnitude * dt)
+                / Mathf.Sqrt(1 + (float)((alpha.magnitude * dt / Constants.c) * (alpha.magnitude * dt / Constants.c)));
+            //var atmp = alpha.magnitude * Time.fixedDeltaTime;
+
 
 
             double[] vtmp = { (atmp * (alpha.x / alpha.magnitude)), 0.0, (atmp * (alpha.z / alpha.magnitude)) };
@@ -75,32 +99,17 @@ public class Planemovement : FlatlandMovement
             v = finaldeltav;
         }
 
-        if ((levelManager.player.transform.position - transform.position).magnitude < 1f)
-        {
-            toggle = true;
-        }
-        else
-        {
-            toggle = false;
-        }
-
-        if(toggle && Input.GetKeyDown("g"))
-        {
-            grabbed = !grabbed;
-        }
+        if (v.magnitude >= Constants.c) // if floating point errors makes object ftl
+            v = v.normalized * (float)(0.999999f * Constants.c);
 
-        if(grabbed)
-        {
-            v = levelManager.player.v;
-            Debug.Log("being grabbed");
-        }
-        
 
         beta = v.magnitude / (float)Constants.c;
 
         gamma = Constants.Gamma(v.magnitude);
 
-        transform.Translate(v * Time.fixedDeltaTime * (float)levelManager.player.gamma, Space.World);
+
+
+        transform.Translate(v * Time.fixedDeltaTime * (float)gamma, Space.World);
 
         var vt = v + (float)Constants.c * Vector3.up;
 
@@ -112,18 +121,20 @@ public class Planemovement : FlatlandMovement
 
 
         transform.localScale = new Vector3(1.0f, 1.0f, 1.0f); // release child to change x'-axis scale
-        theobject.transform.up = vt;
+
+        var neworientation = (Quaternion.FromToRotation(Vector3.up, vt)) * orientation;
+
+        theobject.transform.rotation = Quaternion.LookRotation(neworientation, vt);
 
         theobject.transform.parent = null;
-        theobject.transform.RotateAround(theobject.transform.position, vt, Vector3.Angle(prevorient,orientation));
 
-        Vector3 newforward = new Vector3(vt.y * (v.x/v.magnitude),Mathf.Sqrt(vt.x * vt.x + vt.z *vt.z), vt.y * (v.z / v.magnitude));
+        Vector3 newforward = new Vector3(vt.y * (v.x / v.magnitude), Mathf.Sqrt(vt.x * vt.x + vt.z * vt.z), vt.y * (v.z / v.magnitude));
 
         transform.rotation = Quaternion.LookRotation(newforward, vt);
-        
+
         theobject.transform.parent = transform;
 
-        transform.localScale = new Vector3(1.0f, 1.0f, (float)gamma); // scale x' axis
+        transform.localScale = new Vector3(1.0f, 1.0f, (float)gamma); // scale x'-axis scale (distance dilation)
 
         time += Time.fixedDeltaTime * (float)(levelManager.player.gamma / gamma);
     }

Assets/Scripts/PlayerMovement.cs

@@ -34,11 +34,7 @@ public class PlayerMovement : FlatlandMovement
         var prevfor = transform.forward;
         var prevorient = orientation;
         transform.Translate((float)Constants.c * Vector3.up * Time.fixedDeltaTime * (float)gamma, Space.World); // move up by 1 second
-        cnt++;
-        if (cnt % 480 == 0)
-        {
-            cnt = 0;
-        }
+        
         //transform.Translate(Vector3.forward * Time.fixedDeltaTime, Space.World);
         //transform.Translate(0.5f*Vector3.forward * Mathf.Cos(2*Mathf.PI*cnt/480) * Time.fixedDeltaTime, Space.World);
         //transform.Translate(0.5f*Vector3.left * Mathf.Sin(2 * Mathf.PI * cnt / 480) * Time.fixedDeltaTime, Space.World);
@@ -50,7 +46,11 @@ public class PlayerMovement : FlatlandMovement
         if (alpha.magnitude > 0.0f)
         {
 
-            var atmp = alpha.magnitude * Time.fixedDeltaTime;
+            var dt = (Constants.c / alpha.magnitude) * MathNet.Numerics.Trig.Sinh(alpha.magnitude * Time.fixedDeltaTime / Constants.c);
+            var atmp = (alpha.magnitude * dt)
+                / Mathf.Sqrt(1 + (float)((alpha.magnitude * dt/Constants.c) * (alpha.magnitude * dt / Constants.c)));
+            //var atmp = alpha.magnitude * Time.fixedDeltaTime;
+            
 
 
             double[] vtmp = { (atmp * (alpha.x / alpha.magnitude)), 0.0,(atmp * (alpha.z / alpha.magnitude)) };
@@ -67,7 +67,7 @@ public class PlayerMovement : FlatlandMovement
             {
                 deltav = Constants.BoostMatrix(-v) * deltav;
             }
-
+            
             var tt = deltav[0] / Constants.c;
 
             Vector3 finaldeltav = new Vector3((float)(deltav[1]/tt), 0.0f, (float)(deltav[2]/tt));
@@ -77,6 +77,9 @@ public class PlayerMovement : FlatlandMovement
             v = finaldeltav;
         }
 
+        if (v.magnitude >= Constants.c) // if floating point errors makes object ftl
+            v = v.normalized * (float)(0.999999f * Constants.c);
+
         beta = v.magnitude / (float)Constants.c;
 
         gamma = Constants.Gamma(v.magnitude);
@@ -95,14 +98,12 @@ public class PlayerMovement : FlatlandMovement
 
 
         transform.localScale = new Vector3(1.0f, 1.0f, 1.0f); // release child to change x'-axis scale
-        //theobject.transform.up = vt;
 
         var neworientation = (Quaternion.FromToRotation(Vector3.up, vt)) * orientation;
 
         theobject.transform.rotation = Quaternion.LookRotation(neworientation, vt);
 
         theobject.transform.parent = null;
-        //theobject.transform.RotateAround(theobject.transform.position, vt, Vector3.Angle(prevorient, orientation));
 
         Vector3 newforward = new Vector3(vt.y * (v.x / v.magnitude), Mathf.Sqrt(vt.x * vt.x + vt.z * vt.z), vt.y * (v.z / v.magnitude));
 

Assets/Scripts/UIManager.cs

@@ -115,22 +115,22 @@ public class UIManager : MonoBehaviour
 
         if(Input.GetKeyDown("w"))
         {
-            var tmp = accelslider.GetLogScaleValue();
+            var tmp = accelslider.GetLogScaleValue() * (float)Constants.c * 10;
             levelManager.player.alpha += new Vector3(0, 0, tmp);
         }
         else if(Input.GetKeyDown("a"))
         {
-            var tmp = accelslider.GetLogScaleValue();
+            var tmp = accelslider.GetLogScaleValue() * (float)Constants.c * 10;
             levelManager.player.alpha += new Vector3(-tmp, 0, 0);
         }
         else if(Input.GetKeyDown("s"))
         {
-            var tmp = accelslider.GetLogScaleValue();
+            var tmp = accelslider.GetLogScaleValue() * (float)Constants.c * 10;
             levelManager.player.alpha += new Vector3(0, 0, -tmp);
         }
         else if(Input.GetKeyDown("d"))
         {
-            var tmp = accelslider.GetLogScaleValue();
+            var tmp = accelslider.GetLogScaleValue() * (float)Constants.c * 10;
             levelManager.player.alpha += new Vector3(tmp, 0, 0);
         }
 
@@ -240,7 +240,7 @@ public class UIManager : MonoBehaviour
                     ray = playercamera.ViewportPointToRay(hit.textureCoord);
                     if (Physics.Raycast(ray, out hit))
                     {
-                        levelManager.player.MoveInfinitelyToAbPosition(hit.point, velocityslider.GetLogScaleValue());
+                        levelManager.player.MoveInfinitelyToAbPosition(pathRenderer.transform.InverseTransformPoint(hit.point), velocityslider.GetLogScaleValue());
                         //levelManager.player.MoveToAbPosition(hit.point, velocityslider.GetLogScaleValue());
                         //Debug.Log(velocityslider.GetLogScaleValue() * (float)Constants.c);
                         //Debug.Log(hit.point);