finally finish

Assets/Abstration/PlanetData.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using System;
+
+public static class PlanetData
+{
+    public enum Planet { Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune }
+    public enum KeplerParameter { a, e, I, L, longPeri, longNode, b, c, s, f}
+
+    /// <summary>
+    /// Get planet coordinates at a given time (in AU)
+    /// </summary>
+    /// <param name="p"></param>
+    /// <param name="t"></param>
+    /// <returns></returns>
+    public static Vector3 GetPlanetPosition(Planet p, DateTime t)
+    {
+        float T = (float)(t-new DateTime(2000,1,1)).TotalDays/36525f;
+        float a = GetKeplerParameter(p, KeplerParameter.a)[0] 
+            + (GetKeplerParameter(p, KeplerParameter.a)[1] * T);
+        float longPeri = GetKeplerParameter(p, KeplerParameter.longPeri)[0]
+                    + (GetKeplerParameter(p, KeplerParameter.longPeri)[1] * T);
+        float longNode = GetKeplerParameter(p, KeplerParameter.longNode)[0]
+                    + (GetKeplerParameter(p, KeplerParameter.longNode)[1] * T);
+        float peri = longPeri - longNode;
+        float M = GetKeplerParameter(p, KeplerParameter.L)[0]
+            + (GetKeplerParameter(p, KeplerParameter.L)[1] * T)
+            - longPeri
+            + (GetKeplerParameter(p, KeplerParameter.b)[0] * T * T)
+            + GetKeplerParameter(p, KeplerParameter.c)[0] * Mathf.Cos(Mathf.Deg2Rad*GetKeplerParameter(p, KeplerParameter.f)[0] * T)
+            + GetKeplerParameter(p, KeplerParameter.s)[0] * Mathf.Cos(Mathf.Deg2Rad*GetKeplerParameter(p, KeplerParameter.f)[0] * T);
+
+        M = M % 360 - 180;
+
+        float e = GetKeplerParameter(p, KeplerParameter.e)[0]
+                    + (GetKeplerParameter(p, KeplerParameter.e)[1] * T);
+        float e_star = e * 180 / Mathf.PI;
+
+
+        double E = M - (e_star * Mathf.Sin(Mathf.Deg2Rad*M));
+        double deltaE;
+        //double deltaM;
+        int i = 0;
+        do
+        {
+            //deltaM = M - E + (e_star * Mathf.Sin((float)(Mathf.Deg2Rad*E)));
+            //deltaE = deltaM / (1 - (e_star * Mathf.Cos((float)(Mathf.Deg2Rad*E))));
+            
+            // Don't know why the serie do not converge with order 2 term (see above)
+            // Using only order 1 term instead
+            deltaE = M - E + (e_star * Mathf.Sin((float)(Mathf.Deg2Rad * E)));
+            E += deltaE;
+            i++;
+        } while (Mathf.Abs((float)(deltaE)) > 0.000001 && i<100);
+
+        float x_prime = a * (Mathf.Cos((float)(Mathf.Deg2Rad * E)) - e);
+        float y_prime = a * Mathf.Sqrt(1 - e * e) * Mathf.Sin((float)(Mathf.Deg2Rad*E));
+        
+        float incl = GetKeplerParameter(p, KeplerParameter.I)[0]
+                    + (GetKeplerParameter(p, KeplerParameter.I)[1] * T);
+
+        return new Vector3((Mathf.Cos(Mathf.Deg2Rad * peri) * Mathf.Cos(Mathf.Deg2Rad * longNode) - Mathf.Sin(Mathf.Deg2Rad * peri) * Mathf.Sin(Mathf.Deg2Rad * longNode) * Mathf.Cos(Mathf.Deg2Rad * incl)) * x_prime 
+            + (-Mathf.Sin(Mathf.Deg2Rad * peri) * Mathf.Cos(Mathf.Deg2Rad * longNode) - Mathf.Cos(Mathf.Deg2Rad * peri) * Mathf.Sin(Mathf.Deg2Rad * longNode) * Mathf.Cos(Mathf.Deg2Rad * incl)) * y_prime,
+            (Mathf.Cos(Mathf.Deg2Rad * peri) * Mathf.Sin(Mathf.Deg2Rad * longNode) + Mathf.Sin(Mathf.Deg2Rad * peri) * Mathf.Cos(Mathf.Deg2Rad * longNode) * Mathf.Cos(Mathf.Deg2Rad * incl)) * x_prime
+            + (-Mathf.Sin(Mathf.Deg2Rad * peri) * Mathf.Sin(Mathf.Deg2Rad * longNode) + Mathf.Cos(Mathf.Deg2Rad * peri) * Mathf.Cos(Mathf.Deg2Rad * longNode) * Mathf.Cos(Mathf.Deg2Rad * incl)) * y_prime,
+            Mathf.Sin(Mathf.Deg2Rad * peri) * Mathf.Sin(Mathf.Deg2Rad * incl) * x_prime
+            + Mathf.Cos(Mathf.Deg2Rad * peri) * Mathf.Sin(Mathf.Deg2Rad * incl) * y_prime);
+    }
+
+    private static float[] GetKeplerParameter(Planet planet, KeplerParameter param)
+    {
+        switch (planet)
+        {
+            case Planet.Mercury:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 0.38709927f, 0 };
+                    case KeplerParameter.e:
+                        return new float[] { 0.20563661f, 0.00002123f };
+                    case KeplerParameter.I:
+                        return new float[] { 7.00559432f, -0.00590158f };
+                    case KeplerParameter.L:
+                        return new float[] { 252.25166724f, 149472.67486623f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 77.45771895f, 0.15940013f };
+                    case KeplerParameter.longNode:
+                        return new float[] { 48.33961819f, -0.12214182f };
+                    default:
+                        return new float[] { 0, 0 };
+                }
+            case Planet.Venus:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 0.72332102f, -0.00000026f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.00676399f, -0.00005107f };
+                    case KeplerParameter.I:
+                        return new float[] { 3.39777545f, 0.00043494f };
+                    case KeplerParameter.L:
+                        return new float[] { 181.97970850f, 58517.81560260f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 131.76755713f, 0.05679648f };
+                    case KeplerParameter.longNode:
+                        return new float[] { 76.67261496f, -0.27274174f };
+                    default:
+                        return new float[] { 0, 0 };
+                }
+            case Planet.Earth:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 1.00000018f, -0.00000003f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.01673163f, -0.00003661f };
+                    case KeplerParameter.I:
+                        return new float[] { -0.00054346f, -0.01337178f };
+                    case KeplerParameter.L:
+                        return new float[] { 100.46691572f, 35999.37306329f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 102.93005885f, 0.31795260f };
+                    case KeplerParameter.longNode:
+                        return new float[] { -5.11260389f, -0.24123856f };
+                    default:
+                        return new float[] { 0, 0 };
+                }
+            case Planet.Mars:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 1.52371243f, 0.00000097f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.09336511f, 0.00009149f };
+                    case KeplerParameter.I:
+                        return new float[] { 1.85181869f, -0.00724757f };
+                    case KeplerParameter.L:
+                        return new float[] { -4.56813164f, 19140.29934243f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { -23.91744784f, 0.45223625f };
+                    case KeplerParameter.longNode:
+                        return new float[] { 49.71320984f, -0.26852431f };
+                    default:
+                        return new float[] { 0, 0 };
+                }
+            case Planet.Jupiter:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 5.20248019f, -0.00002864f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.04853590f, 0.00018026f };
+                    case KeplerParameter.I:
+                        return new float[] { 1.29861416f, -0.00322699f };
+                    case KeplerParameter.L:
+                        return new float[] { 34.33479152f, 3034.90371757f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 14.27495244f, 0.18199196f };
+                    case KeplerParameter.longNode:
+                        return new float[] { 100.29282654f, 0.13024619f };
+                    case KeplerParameter.b:
+                        return new float[] { -0.00012452f, 0 };
+                    case KeplerParameter.c:
+                        return new float[] { 0.06064060f, 0 };
+                    case KeplerParameter.s:
+                        return new float[] { -0.35635438f, 0 };
+                    case KeplerParameter.f:
+                        return new float[] { 38.35125000f, 0 };
+                }
+                break;
+            case Planet.Saturn:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 9.54149883f, -0.00003065f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.05550825f, -0.00032044f };
+                    case KeplerParameter.I:
+                        return new float[] { 2.49424102f, 0.00451969f };
+                    case KeplerParameter.L:
+                        return new float[] { 50.07571329f, 1222.11494724f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 92.86136063f, 0.54179478f };
+                    case KeplerParameter.longNode:
+                        return new float[] { 113.63998702f, -0.25015002f };
+                    case KeplerParameter.b:
+                        return new float[] { 0.00025899f, 0 };
+                    case KeplerParameter.c:
+                        return new float[] { -0.13434469f, 0 };
+                    case KeplerParameter.s:
+                        return new float[] { 0.87320147f, 0 };
+                    case KeplerParameter.f:
+                        return new float[] { 38.35125000f, 0 };
+                }
+                break;
+            case Planet.Uranus:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 19.18797948f, -0.00020455f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.04685740f, -0.00001550f };
+                    case KeplerParameter.I:
+                        return new float[] { 0.77298127f, -0.00180155f };
+                    case KeplerParameter.L:
+                        return new float[] { 314.20276625f, 428.49512595f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 172.43404441f, 0.09266985f};
+                    case KeplerParameter.longNode:
+                        return new float[] { 73.96250215f, 0.05739699f };
+                    case KeplerParameter.b:
+                        return new float[] { 0.00058331f, 0 };
+                    case KeplerParameter.c:
+                        return new float[] { -0.97731848f, 0 };
+                    case KeplerParameter.s:
+                        return new float[] { 0.17689245f, 0 };
+                    case KeplerParameter.f:
+                        return new float[] { 7.67025000f, 0 };
+                }
+                break;
+            case Planet.Neptune:
+                switch (param)
+                {
+                    case KeplerParameter.a:
+                        return new float[] { 30.06952752f, 0.00006447f };
+                    case KeplerParameter.e:
+                        return new float[] { 0.00895439f, 0.00000818f };
+                    case KeplerParameter.I:
+                        return new float[] { 1.77005520f, 0.00022400f };
+                    case KeplerParameter.L:
+                        return new float[] { 304.22289287f, 218.46515314f };
+                    case KeplerParameter.longPeri:
+                        return new float[] { 46.68158724f, 0.01009938f };
+                    case KeplerParameter.longNode:
+                        return new float[] { 131.78635853f, -0.00606302f};
+                    case KeplerParameter.b:
+                        return new float[] { -0.00041348f, 0 };
+                    case KeplerParameter.c:
+                        return new float[] { 0.68346318f, 0 };
+                    case KeplerParameter.s:
+                        return new float[] { -0.10162547f, 0 };
+                    case KeplerParameter.f:
+                        return new float[] { 7.67025000f, 0 };
+                }
+                break;
+        }
+        return new float[] { 0, 0 };
+    }
+}
\ No newline at end of file

Assets/NewBehaviourScript.cs.meta → Assets/Abstration/PlanetData.cs.meta

 fileFormatVersion: 2
-guid: 9e5b2851f132f274889e148e5ab67a27
+guid: c5eb536e569afad41bf8b705683e72c0
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Assets/Abstration/PlanetManager.cs

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PlanetManager : MonoBehaviour
+{
+
+    public static PlanetManager current;
+
+    private void Awake()
+    {
+        if (current == null)
+        {
+            current = this;
+        }
+        else
+        {
+            Destroy(obj:this);
+        }
+    }
+
+
+    [SerializeField]
+    private UDateTime date;
+    public event Action<DateTime> OnTimeChange;
+
+    public UDateTime Date
+    {
+        get => date;
+        set
+        {
+            date = value;
+            TimeChanged(value.dateTime);  // activate when time changess
+        }
+    }
+
+    public void TimeChanged(DateTime newTime)
+    {
+        // 当日期改变时，更新行星的位置或触发其他事件
+        OnTimeChange?.Invoke(newTime);
+        Debug.Log("Time changed to: " + newTime);
+    }
+    // Start is called before the first frame update
+    void Start()
+    {
+        
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        
+    }
+}

Assets/Abstration/PlanetManager.cs.meta

+fileFormatVersion: 2
+guid: cc3d4cbb335fc814189c0dc02941a1fd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Controller/DateController.cs

+using UnityEngine;
+using UnityEngine.UI;
+using System;
+
+public class DateController : MonoBehaviour
+{
+    public Text dateText;                // 用于显示当前日期的 Text 组件
+    public InputField dateInputField;    // 用于输入新日期的 InputField 组件
+    public Button setDateButton;         // 设置日期的按钮
+    public SolarSystemController solarSystemController;  // 引用 SolarSystemController
+
+    void Start()
+    {
+        // 初始化时显示当前日期
+        UpdateDateDisplay();
+
+        // 为按钮添加点击事件监听
+        setDateButton.onClick.AddListener(OnSetDateButtonClick);
+    }
+
+    // 更新 UI 上显示的当前日期
+    void UpdateDateDisplay()
+    {
+        DateTime currentDate = solarSystemController.GetCurrentDate();  // 获取 SolarSystemController 中的当前日期
+        dateText.text = "Current Date: " + currentDate.ToString("yyyy-MM-dd");
+    }
+
+    // 当点击 "Set Date" 按钮时调用
+    void OnSetDateButtonClick()
+    {
+        string newDateString = dateInputField.text;  // 获取输入框中的日期字符串
+        DateTime newDate;
+
+        // 尝试解析用户输入的日期
+        if (DateTime.TryParse(newDateString, out newDate))
+        {
+            // 如果解析成功，更新 SolarSystemController 中的日期
+            solarSystemController.SetCurrentDate(newDate);
+
+            // 更新 UI 上的日期显示
+            UpdateDateDisplay();
+
+            Debug.Log("New date set: " + newDate.ToString("yyyy-MM-dd"));
+        }
+        else
+        {
+            Debug.LogWarning("Invalid date format. Please enter a valid date (yyyy-MM-dd).");
+        }
+
+        // 清空输入框内容
+        dateInputField.text = "";
+    }
+}

Assets/Controller/DateController.cs.meta

+fileFormatVersion: 2
+guid: 5022034c704ca294b9673f94005a59b5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Controller/FreeCameraController.cs

+using UnityEngine;
+
+public class FreeCameraController : MonoBehaviour
+{
+    public float moveSpeed = 10f;           // 摄像机移动速度
+    public float rotationSpeed = 100f;      // 摄像机旋转速度
+    public float zoomSpeed = 300f;           // 摄像机缩放速度
+    public float minZoomDistance = 5f;      // 缩放最小距离
+    public float maxZoomDistance = 100f;    // 缩放最大距离
+    private float yaw = 0.0f;               // 用于水平旋转的角度
+    private float pitch = 0.0f;             // 用于垂直旋转的角度
+
+    void Update()
+    {
+        HandleMovement();   // 处理键盘移动
+        HandleMouseRotation(); // 处理鼠标旋转
+        HandleZoom();       // 处理鼠标滚轮缩放
+    }
+
+    // 处理键盘输入，控制摄像机的自由移动
+    void HandleMovement()
+    {
+        float moveX = Input.GetAxis("Horizontal");  // A/D 或 左/右箭头
+        float moveZ = Input.GetAxis("Vertical");    // W/S 或 上/下箭头
+
+        // 使用 Shift 键加快移动速度
+        float speed = moveSpeed;
+        if (Input.GetKey(KeyCode.LeftShift))
+        {
+            speed *= 2;
+        }
+
+        // 上下移动
+        float moveY = 0;
+        if (Input.GetKey(KeyCode.Space))  // 上升
+        {
+            moveY = 1;
+        }
+        else if (Input.GetKey(KeyCode.LeftControl))  // 下降
+        {
+            moveY = -1;
+        }
+
+        // 移动摄像机
+        Vector3 move = transform.right * moveX + transform.up * moveY + transform.forward * moveZ;
+        transform.position += move * speed * Time.deltaTime;
+    }
+
+    // 处理鼠标输入，控制摄像机旋转
+    void HandleMouseRotation()
+    {
+        if (Input.GetMouseButton(1))  // 按住右键旋转摄像机
+        {
+            yaw += Input.GetAxis("Mouse X") * rotationSpeed * Time.deltaTime;
+            pitch -= Input.GetAxis("Mouse Y") * rotationSpeed * Time.deltaTime;
+
+            // 将旋转应用到摄像机上
+            transform.eulerAngles = new Vector3(pitch, yaw, 0.0f);
+        }
+    }
+
+    // 处理鼠标滚轮缩放视角
+    void HandleZoom()
+    {
+        float scroll = Input.GetAxis("Mouse ScrollWheel");
+        Vector3 direction = transform.forward * scroll * zoomSpeed * Time.deltaTime;
+
+        // 计算新的摄像机位置
+        Vector3 newPosition = transform.position + direction;
+
+        // 限制摄像机缩放的最小和最大距离
+        float distanceFromOrigin = Vector3.Distance(newPosition, Vector3.zero);
+        if (distanceFromOrigin >= minZoomDistance && distanceFromOrigin <= maxZoomDistance)
+        {
+            transform.position = newPosition; // 更新摄像机位置
+        }
+    }
+}

Assets/Controller/FreeCameraController.cs.meta

+fileFormatVersion: 2
+guid: 783155ffdd746024282ca78cf74bfb75
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Controller/OrbitController.cs

+using UnityEngine;
+using UnityEngine.UI;
+
+public class UIOrbitController : MonoBehaviour
+{
+    public OrbitRenderer[] planetOrbits;   // 行星轨道的渲染器数组
+    public Button toggleOrbitButton;       // 控制轨道显示/隐藏的按钮
+    private bool isOrbitVisible = true;    // 轨道是否可见的状态
+
+    void Start()
+    {
+        // 初始化按钮事件
+        if (toggleOrbitButton != null)
+        {
+            toggleOrbitButton.onClick.AddListener(ToggleOrbitVisibility);
+            // 初始化按钮文本
+            toggleOrbitButton.GetComponentInChildren<Text>().text = isOrbitVisible ? "Hide Orbits" : "Show Orbits";
+        }
+    }
+
+    // 切换轨道的显现与消失
+    void ToggleOrbitVisibility()
+    {
+        isOrbitVisible = !isOrbitVisible;  // 切换当前轨道状态
+
+        // 更新所有行星轨道的可见性
+        foreach (var orbit in planetOrbits)
+        {
+            orbit.ToggleOrbitVisibility(isOrbitVisible);
+        }
+
+        // 更新按钮文本
+        toggleOrbitButton.GetComponentInChildren<Text>().text = isOrbitVisible ? "Hide Orbits" : "Show Orbits";
+    }
+}
+

Assets/Controller/OrbitController.cs.meta

+fileFormatVersion: 2
+guid: fd2f110e7832c1342b3be7ce00466959
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Controller/PauseResumeController.cs

+using UnityEngine;
+using UnityEngine.UI;
+
+public class TimeController : MonoBehaviour
+{
+    public Button pauseResumeButton;          // UI按钮用于控制暂停和恢复
+    public SolarSystemController solarSystemController; // 引用SolarSystemController
+
+    private bool isPaused = false;            // 标记当前是否处于暂停状态
+    private float savedDaysPerFrame;          // 用于存储恢复时间时的daysPerFrame值
+
+    void Start()
+    {
+        // 监听按钮点击事件
+        pauseResumeButton.onClick.AddListener(PauseOrResumeTime);
+        UpdateButtonText();  // 初始化按钮文本
+    }
+
+    // 切换暂停与恢复
+    void PauseOrResumeTime()
+    {
+        if (isPaused)
+        {
+            ResumeTime();    // 如果当前是暂停状态，恢复时间
+        }
+        else
+        {
+            PauseTime();     // 如果当前是运行状态，暂停时间
+        }
+    }
+
+    // 暂停时间
+    void PauseTime()
+    {
+        // 保存当前的daysPerFrame
+        savedDaysPerFrame = solarSystemController.daysPerFrame;
+
+        // 将daysPerFrame设置为0，停止所有的时间推进
+        solarSystemController.daysPerFrame = 0;
+
+        isPaused = true;  // 更新暂停状态
+        UpdateButtonText();  // 更新按钮文本
+    }
+
+    // 恢复时间
+    void ResumeTime()
+    {
+        // 恢复之前保存的daysPerFrame
+        solarSystemController.daysPerFrame = savedDaysPerFrame;
+
+        isPaused = false;  // 更新暂停状态
+        UpdateButtonText();  // 更新按钮文本
+    }
+
+    // 更新按钮文本
+    void UpdateButtonText()
+    {
+        pauseResumeButton.GetComponentInChildren<Text>().text = isPaused ? "Resume" : "Pause";
+    }
+}
+

Assets/Controller/PauseResumeController.cs.meta

+fileFormatVersion: 2
+guid: 321ec61af2f6c6c4f936de622851ebe6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Controller/PlanetClickController.cs

+using UnityEngine;
+
+public class PlanetClickController : MonoBehaviour
+{
+    public Camera mainCamera;                              // 主摄像机
+    public float cameraFollowSpeed = 2.0f;                 // 摄像机跟随的速度
+    private Transform targetPlanet;                        // 当前选中的行星
+    private bool isFollowing = false;                      // 标记摄像机是否在跟随行星
+
+    void Update()
+    {
+        // 检测鼠标点击
+        if (Input.GetMouseButtonDown(0))  // 0 表示左键点击
+        {
+            CheckPlanetClick();
+        }
+
+        // 检测是否按下 Escape 键来退出跟随模式
+        if (Input.GetKeyDown(KeyCode.Escape))
+        {
+            isFollowing = false;
+            targetPlanet = null;
+            Debug.Log("Exited Follow Mode by Escape.");
+        }
+
+        // 如果摄像机正在跟随行星
+        if (isFollowing && targetPlanet != null)
+        {
+            FollowPlanet();
+        }
+    }
+
+
+    // 检查用户点击的是否为行星
+    void CheckPlanetClick()
+    {
+        // 通过摄像机射线检测点击
+        Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
+        RaycastHit hit;
+
+        if (Physics.Raycast(ray, out hit))
+        {
+            // 检查被点击的物体是否有行星标签
+            if (hit.collider != null && hit.collider.CompareTag("Planet"))
+            {
+                // 如果点击的是行星，开始跟随该行星
+                targetPlanet = hit.transform;  // 获取行星的 Transform
+                isFollowing = true;
+                Debug.Log("Selected Planet: " + targetPlanet.name);
+            }
+        }
+        else
+        {
+            // 如果点击空白区域，取消跟随
+            isFollowing = false;
+            targetPlanet = null;
+            Debug.Log("Exited Follow Mode.");
+        }
+    }
+
+
+    // 摄像机跟随行星
+    void FollowPlanet()
+    {
+        // 获取目标行星的位置
+        Vector3 targetPosition = targetPlanet.position;
+
+        // 定义一个摄像机的偏移距离，使摄像机保持在行星的前方或合理距离外
+        float distanceFromPlanet = 2f; // distance from the planet
+        Vector3 offset = new Vector3(0, 0, -distanceFromPlanet);
+
+        // 平滑移动摄像机到行星前方的一个合理位置
+        Vector3 desiredPosition = targetPlanet.position + targetPlanet.forward * -distanceFromPlanet;  // 可以根据需要调整这个偏移量
+        Vector3 smoothedPosition = Vector3.Lerp(mainCamera.transform.position, desiredPosition, cameraFollowSpeed * Time.deltaTime);
+
+        // 更新摄像机的位置，并确保行星始终在屏幕中央
+        mainCamera.transform.position = smoothedPosition;
+        mainCamera.transform.LookAt(targetPlanet);  // 始终保持摄像机朝向行星
+    }
+
+}

Assets/Controller/PlanetClickController.cs.meta

+fileFormatVersion: 2
+guid: f820f1bed18711848a7abf1b6515a100
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Controller/SolarSystemControl.cs

-using System.Collections;
+using System;
 using System.Collections.Generic;
 using UnityEngine;
 
-public class SolarSystemControl : MonoBehaviour
+public class SolarSystemController : MonoBehaviour
 {
-    // Start is called before the first frame update
+    public PlanetManager planetManager;
+    public float daysPerFrame = 0.1f;  // 每帧时间步长天数
+    private Dictionary<PlanetData.Planet, GameObject> planetGameObjects;
+    private Dictionary<PlanetData.Planet, float> planetRotationSpeeds;
+    private Dictionary<PlanetData.Planet, OrbitRenderer> planetOrbits;
+
+    public DateTime currentDate;  // 添加类成员变量，用于存储当前日期
+
+    public GameObject mercury;
+    public GameObject venus;
+    public GameObject earth;
+    public GameObject mars;
+    public GameObject jupiter;
+    public GameObject saturn;
+    public GameObject uranus;
+    public GameObject neptune;
+
+    public OrbitRenderer mercuryOrbit;
+    public OrbitRenderer venusOrbit;
+    public OrbitRenderer earthOrbit;
+    public OrbitRenderer marsOrbit;
+    public OrbitRenderer jupiterOrbit;
+    public OrbitRenderer saturnOrbit;
+    public OrbitRenderer uranusOrbit;
+    public OrbitRenderer neptuneOrbit;
+
     void Start()
     {
+        // 初始化当前日期为系统当前时间
+        currentDate = DateTime.Now;
+
+        planetGameObjects = new Dictionary<PlanetData.Planet, GameObject>
+        {
+            { PlanetData.Planet.Mercury, mercury },
+            { PlanetData.Planet.Venus, venus },
+            { PlanetData.Planet.Earth, earth },
+            { PlanetData.Planet.Mars, mars },
+            { PlanetData.Planet.Jupiter, jupiter },
+            { PlanetData.Planet.Saturn, saturn },
+            { PlanetData.Planet.Uranus, uranus },
+            { PlanetData.Planet.Neptune, neptune }
+        };
+
+        planetRotationSpeeds = new Dictionary<PlanetData.Planet, float>
+        {
+            { PlanetData.Planet.Mercury, 6.14f },
+            { PlanetData.Planet.Venus, -1.48f },
+            { PlanetData.Planet.Earth, 360f },
+            { PlanetData.Planet.Mars, 350.89f },
+            { PlanetData.Planet.Jupiter, 870.5f },
+            { PlanetData.Planet.Saturn, 810.79f },
+            { PlanetData.Planet.Uranus, -501.16f },
+            { PlanetData.Planet.Neptune, 536.31f }
+        };
+
+        planetOrbits = new Dictionary<PlanetData.Planet, OrbitRenderer>
+        {
+            { PlanetData.Planet.Mercury, mercuryOrbit },
+            { PlanetData.Planet.Venus, venusOrbit },
+            { PlanetData.Planet.Earth, earthOrbit },
+            { PlanetData.Planet.Mars, marsOrbit },
+            { PlanetData.Planet.Jupiter, jupiterOrbit },
+            { PlanetData.Planet.Saturn, saturnOrbit },
+            { PlanetData.Planet.Uranus, uranusOrbit },
+            { PlanetData.Planet.Neptune, neptuneOrbit }
+        };
 
+        PlanetManager.current.OnTimeChange += UpdatePosition;
     }
 
-    // Update is called once per frame
     void Update()
     {
+        // 每帧增加时间
+        currentDate = currentDate.AddDays(daysPerFrame);
+
+        // 更新 PlanetManager 的时间
+        planetManager.Date = new UDateTime { dateTime = currentDate };
+
+        // 更新行星位置
+        UpdatePosition(currentDate);
+
+        // 更新每个行星的自转
+        RotatePlanets(daysPerFrame);
+    }
+
+    // 允许外部脚本获取当前日期
+    public DateTime GetCurrentDate()
+    {
+        return currentDate;
+    }
+
+    // 允许外部脚本设置当前日期
+    public void SetCurrentDate(DateTime newDate)
+    {
+        currentDate = newDate;
+        planetManager.Date = new UDateTime { dateTime = currentDate };
+        UpdatePosition(currentDate);
+    }
+
+    void UpdatePosition(DateTime t)
+    {
+        foreach (PlanetData.Planet planet in Enum.GetValues(typeof(PlanetData.Planet)))
+        {
+            Vector3 position = PlanetData.GetPlanetPosition(planet, t);
+            if (planetGameObjects.ContainsKey(planet))
+            {
+                planetGameObjects[planet].transform.position = position;
+
+                if (planetOrbits.ContainsKey(planet))
+                {
+                    planetOrbits[planet].AddPosition(position);
+                }
+            }
+        }
+    }
 
+    void RotatePlanets(float daysPerFrame)
+    {
+        foreach (PlanetData.Planet planet in Enum.GetValues(typeof(PlanetData.Planet)))
+        {
+            if (planetGameObjects.ContainsKey(planet))
+            {
+                float rotationSpeed = 360f * (daysPerFrame / (360.0f / planetRotationSpeeds[planet]));
+                planetGameObjects[planet].transform.Rotate(Vector3.up, rotationSpeed * Time.deltaTime);
+            }
         }
     }
+}
+

Assets/Controller/UIController.cs

+using UnityEngine;
+using UnityEngine.UI;
+
+public class UIController : MonoBehaviour
+{
+    public Slider timeSpeedSlider;    // 控制时间流速的滑动条
+    public Slider scaleSlider;        // 控制视角缩放的滑动条
+    public Text timeSpeedValueText;   // 显示时间流速的文本
+    public Text scaleValueText;       // 显示缩放比例的文本
+
+    public SolarSystemController solarSystemController;  // 引用太阳系控制器
+    public Camera mainCamera;         // 引用摄像机
+
+    private float defaultFieldOfView;  // 摄像机的默认视野（FOV）
+
+    void Start()
+    {
+        // 初始化滑动条的默认值
+        if (timeSpeedSlider != null)
+        {
+            timeSpeedSlider.value = solarSystemController.daysPerFrame;  // 初始化为daysPerFrame的值
+            timeSpeedValueText.text = "Time Speed: " + timeSpeedSlider.value.ToString("F2");
+        }
+
+        if (scaleSlider != null && mainCamera != null)
+        {
+            defaultFieldOfView = mainCamera.fieldOfView;  // 获取透视摄像机的默认视野（FOV）
+            scaleSlider.value = 1f;  // 默认缩放比例为1
+            scaleValueText.text = "Scale: " + scaleSlider.value.ToString("F2");
+        }
+    }
+
+    // 当滑动条的值发生变化时，更新时间流速
+    public void OnTimeSpeedChanged()
+    {
+        if (solarSystemController != null && timeSpeedSlider != null)
+        {
+            solarSystemController.daysPerFrame = timeSpeedSlider.value;  // 根据滑动条值调整daysPerFrame
+            timeSpeedValueText.text = "Time Speed: " + timeSpeedSlider.value.ToString("F2");
+        }
+    }
+
+    // 当滑动条的值发生变化时，更新视角缩放
+    public void OnScaleChanged()
+    {
+        if (mainCamera != null && scaleSlider != null)
+        {
+            // 调整摄像机的缩放比例，使用fieldOfView控制透视摄像机缩放
+            mainCamera.fieldOfView = defaultFieldOfView * scaleSlider.value;
+            scaleValueText.text = "Scale: " + scaleSlider.value.ToString("F2");
+        }
+    }
+}

Assets/Controller/UIController.cs.meta

+fileFormatVersion: 2
+guid: 8c34f1156395ccb4da785f1e4b99421c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ModularFirstPersonController.meta

+fileFormatVersion: 2
+guid: a0cf98457b2a82d4b98454f5ae9fc7aa
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ModularFirstPersonController/DemoScene.meta

+fileFormatVersion: 2
+guid: 7d2c7648db4398a488c3e3a2d79fab5f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: