Project_SubstationMaintenance_G_YunNan_2025/ChivaTechFramework/Assets/Scripts/Tool/LuoShuanMenuAnimation.cs

using ChivaXR;
using Sirenix.OdinInspector;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEngine;

[ExecuteInEditMode]
public class LuoShuanMenuAnimation : SerializedMonoBehaviour
{
    ///螺栓长短不一时，动画无法适配
    ///不适配成双螺丝，多组螺丝位置分散时，操作麻烦
    ///类型得手选，听鸡肋的，点着麻烦。默认排序也有问题，应该默认螺母
    private bool showAniInfo = false;
    private float timer = 0;
    private bool isInit = true;
    private LuoShuanObj aniMenuItem;
    private int objListCount = 0;
    private int runListIndex = 0;
    private int aniState = 0;
    private int num = 0;
   //[HideInInspector]
    public bool reverse = false;
    private float lerp;
    /// <summary> 存放锚点服务体的列表 </summary>
    private List<GameObject> tempMenuList = new List<GameObject>();

    public enum objType { 螺母, 垫片,螺丝 }

    [Tooltip("和物体名称一样，只用于在执行队列中起提示作用，无实际代码逻辑作用")]
    [LabelText("物体类型"), PropertyOrder(0),OnValueChanged("ChangeType")]
    public objType itemType = objType.螺母;
    void ChangeType()
    {
        objName= itemType.ToString();
        if (objName.Equals("垫片"))
        {
            localMovePos = Vector3.zero;
            rotAngle = 0;
            duration = 0;
            showAniInfo = true;
        }
        else
        {
            rotAngle = -360;
            duration = 2;
            showAniInfo = false;
        }
    }
    [LabelText("是否对角拆除"), PropertyOrder(0)]
    public bool playType = true;

    [Tooltip("和物体类型一样，只用于在执行队列中起提示作用，无实际代码逻辑作用")]
    [LabelText("物体名称"), PropertyOrder(0)]
    public string objName = "螺母";

    [FoldoutGroup("动画属性"), LabelText("移动方向"), PropertyOrder(1),HideIf("showAniInfo")]
    public Vector3 localMovePos;

    [FoldoutGroup("动画属性"), LabelText("旋转角度"), PropertyOrder(1), HideIf("showAniInfo")]
    public float rotAngle = 0;

    [FoldoutGroup("动画属性"), LabelText("运行时长"), PropertyOrder(1), HideIf("showAniInfo")]
    public float duration;


    [LabelText("执行队列"), PropertyOrder(1)]
    public List<LuoShuanObj> menuList = new List<LuoShuanObj>();

    public void SetInitState()
    {
        foreach (LuoShuanObj obj in menuList)
        {
            for (int i = 0; i < obj.objList.Count; i++)
            {
                if (!reverse)
                {
                    obj.objList[i].transform.position = obj.tmpList[i].transform.position;
                    obj.objList[i].transform.rotation = obj.tmpList[i].transform.rotation;
                    obj.objList[i].SetActive(true);
                }
                else
                {
                    obj.objList[i].transform.position = obj.tmpList[i].transform.position + obj.tmpList[i].transform.TransformDirection(obj.localMovePos);
                    obj.objList[i].transform.rotation = obj.tmpList[i].transform.rotation;
                    obj.objList[i].transform.RotateAround(obj.tmpList[i].transform.position, obj.tmpList[i].transform.TransformDirection(obj.localMovePos), obj.rotAngle);
                    obj.objList[i].SetActive(false);
                }
            }
        }
    }

    public void SetFinishedState()
    {
        foreach (LuoShuanObj obj in menuList)
        {
            for (int i = 0; i < obj.objList.Count; i++)
            {
                if (reverse)
                {
                    obj.objList[i].transform.position = obj.tmpList[i].transform.position;
                    obj.objList[i].transform.rotation = obj.tmpList[i].transform.rotation;
                    obj.objList[i].SetActive(true);
                }
                else
                {
                    obj.objList[i].transform.position = obj.tmpList[i].transform.position + obj.tmpList[i].transform.TransformDirection(obj.localMovePos);
                    obj.objList[i].transform.rotation = obj.tmpList[i].transform.rotation;
                    obj.objList[i].transform.RotateAround(obj.tmpList[i].transform.position, obj.tmpList[i].transform.TransformDirection(obj.localMovePos), obj.rotAngle);
                    obj.objList[i].SetActive(false);
                }
            }
        }
    }

#if UNITY_EDITOR
    [Button("添加组"), PropertyOrder(2)]
    public void AddMenu()
    {
        if (Selection.gameObjects.Length == 0) return;
        List<LsListSort> objList = new List<LsListSort> ();

        try
        {
            foreach (GameObject obj in Selection.gameObjects)
            {
                objList.Add(new LsListSort(obj));
            }
            objList.Sort(objListSort);
        }
        catch (Exception)
        {
            infoStr = "选中的物体无法添加\n请检查选中物体的名称后缀是否为三个数字";
            infoBoxIsShow = true;
            return;
        }
        infoBoxIsShow = false;
        
        List<GameObject> sortList = new List<GameObject>();
        foreach (LsListSort obj in objList)
        {
            sortList.Add(obj.Object);
        }

        menuList.Add(new LuoShuanObj(objName, sortList, localMovePos, rotAngle, duration, new List<GameObject>(), showAniInfo,itemType));

    }

    [Button("生成锚点"), PropertyOrder(2)]
    public void AddSelectObj()
    {
        if (tempMenuList.Count != 0)
        {
            foreach (GameObject obj in tempMenuList)
                DestroyImmediate(obj);
            tempMenuList.Clear();
        }
        if (menuList.Count != 0)
            foreach (LuoShuanObj lsObj in menuList)
            {
                if (lsObj.tmpList.Count != 0)
                {
                    foreach (GameObject obj in lsObj.tmpList)
                        DestroyImmediate(obj);
                }
                lsObj.tmpList.Clear();
            }

        foreach (LuoShuanObj lsObj in menuList)
        {
            if (lsObj.objList.Count == 0) return;

            GameObject tmpList = new GameObject("锚点组_" + lsObj.objName);
            tmpList.transform.parent = transform;
            foreach (GameObject obj in lsObj.objList)
            {
                GameObject tmpItem = new GameObject("锚点_" + obj.gameObject.name);
                tmpItem.transform.parent = tmpList.transform;
                tmpItem.transform.position = obj.transform.position;
                tmpItem.transform.rotation = obj.transform.rotation;

                lsObj.tmpList.Add(tmpItem);
            }
            tempMenuList.Add(tmpList);
        }
    }

    [ShowIf("infoBoxIsShow"), PropertyOrder(3)]
    [DisplayAsString]
    public string infoStr = "目前只支持4倍数的物体，请检查";
    private bool infoBoxIsShow = false;

    [Button("Play"), PropertyOrder(2)]
    public void Play()
    {
        isPlaying = true;
        timer = 0;
        isInit = true;
        objListCount = 0;
        runListIndex = 0;
        if (reverse)
            aniState = menuList.Count - 1;
        else
            aniState = 0;
        num = 0;
    }



    [HideInInspector]
    public bool isPlaying;

    [HideInInspector]
    public bool isShowPath = true;
    public bool ShowPath { get { return isShowPath; } }

    private void OnDrawGizmos()
    {
        DrawPathLine();
    }

    public void DrawPathLine()
    {
        if (!isShowPath) return;
        if (tempMenuList.Count != 0)
        {
            foreach (LuoShuanObj lsObj in menuList)
            {
                if (lsObj.tmpList.Count != 0)
                {
                    switch (lsObj.itemType)
                    {
                        case objType.螺丝: Gizmos.color = Color.yellow; break;
                        case objType.螺母: Gizmos.color = Color.blue; break;
                            //case objType.垫片: return;
                    }
                    Gizmos.DrawLine(lsObj.tmpList[1].transform.position, lsObj.tmpList[1].transform.position + lsObj.tmpList[1].transform.TransformDirection(lsObj.localMovePos));
                }
            }
        }


    }

    private void OnEnable()
    {
        EditorApplication.update += EditorUpdate;

        Selection.selectionChanged += SelectionChanged;
    }
    private void OnDisable()
    {
        EditorApplication.update -= EditorUpdate;
        Selection.selectionChanged -= SelectionChanged;
    }


    void EditorUpdate()
    {
        if (!isPlaying) return;

        foreach (LuoShuanObj obj in menuList)
        {
            if (obj.objList.Count == 0)
            {
                infoStr = "无物体对象数据，请检查";
                infoBoxIsShow = true;
                return;
            }

            if (obj.tmpList.Count == 0)
            {
                infoStr = "无锚点数据，请检查";
                infoBoxIsShow = true;
                return;
            }

            if (objListCount == 0)
                objListCount = obj.objList.Count;
            else
                if (objListCount != obj.objList.Count)
                {
                    infoStr = "列表物体数量不匹配，请检查";
                    infoBoxIsShow = true;
                    return;
                }

            if(objListCount %4 != 0 && playType == true)
            {
                infoStr = "目前只支持4倍数的物体，请检查";
                infoBoxIsShow = true;
                return;
            }

            infoBoxIsShow = false;
        }

        if (isInit)
        {
            aniMenuItem = menuList[aniState];
            isInit = false;
        }

        if (reverse)
        {
            lerp = (1 - timer / aniMenuItem.duration);
        }
        else
        {
            lerp = timer / aniMenuItem.duration;
        }

        if (aniMenuItem.localMovePos != Vector3.zero)
        {
            if (playType == true)
            {
                PlayByDJ();
            }
            else
            {
                PlayByList();
            }

        }

        timer += Time.deltaTime;

        if (timer > aniMenuItem.duration)
        {
            timer = 0;

            if (playType == true)
            {
                HideObjByDJ();
            }
            else
            {
                HideObjBylist();
            }


            if (reverse)
                if (--aniState < 0)
                {
                    aniState = menuList.Count - 1;

                    if (num % 2 != 0)
                        runListIndex++;
                    num++;
                }

            if (!reverse)
                if (++aniState > menuList.Count - 1)
                {
                    aniState = 0;

                    if (num % 2 != 0)
                        runListIndex++;
                    num++;
                }

            aniMenuItem = menuList[aniState];
            if (runListIndex > objListCount / 4-1)
            {

                foreach (LuoShuanObj obj in menuList)
                {
                    for (int i = 0; i < obj.objList.Count; i++)
                    {
                        if (obj.duration != 0 )
                        {
                            obj.objList[i].transform.position = obj.tmpList[i].transform.position;
                            obj.objList[i].transform.rotation = obj.tmpList[i].transform.rotation;
                        }
                        obj.objList[i].SetActive(true);
                    }
                }
                isPlaying = false;
            }
        }
    }

    public int objListSort(LsListSort obj1, LsListSort obj2)
    {
        if (obj1.objNameNum > obj2.objNameNum)
            return 1;
        else
            return -1;
    }

    public class LsListSort
    {
        public GameObject Object;
        public int objNameNum;

        public LsListSort(GameObject Object)
        {
            this.Object = Object;
            if(Object.name.Length>3)
            objNameNum = Convert.ToInt32(Object.name.Substring(Object.name.Length - 3, 3));
            else
                objNameNum = Convert.ToInt32(Object.name);
        }

    }
    void SelectionChanged()
    {
        if (Selection.gameObjects.Contains(this.gameObject))
        {
            isShowPath = true;
        }
        else
        {
            isShowPath = false;
        }
    }
#endif

    public IEnumerator IEAniPlay(Action finishedCallBack = null)
    {
        timer = 0;
        isInit = true;
        objListCount = 0;
        runListIndex = 0;
        if (reverse)
            aniState = menuList.Count - 1;
        else
            aniState = 0;
        num = 0;
        foreach (LuoShuanObj obj in menuList)
        {
            if (obj.objList.Count == 0)
            {
                Debug.Log( "无物体对象数据，请检查");
                StopCoroutine(IEAniPlay());
                yield return new WaitForEndOfFrame();
            }

            if (obj.tmpList.Count == 0)
            {
                Debug.Log("无锚点数据，请检查");
                StopCoroutine(IEAniPlay());
                yield return new WaitForEndOfFrame();
            }

            if (objListCount == 0)
                objListCount = obj.objList.Count;
            else
                if (objListCount != obj.objList.Count)
            {
                Debug.Log("列表物体数量不匹配，请检查");
                StopCoroutine(IEAniPlay());
                yield return new WaitForEndOfFrame();
            }

            if (objListCount % 4 != 0 && playType)
            {
                Debug.Log("目前只支持4倍数的物体，请检查");
                StopCoroutine(IEAniPlay());
                yield return new WaitForEndOfFrame();
            }
        }

        aniMenuItem = menuList[aniState];

        while (runListIndex < objListCount / 4 )
        {
            if(playType == true)
            {
                PlayByDJ();
            }
            else
            {
                PlayByList();
            }

            timer += Time.deltaTime;

            if (timer > aniMenuItem.duration)
            {
                timer = 0;

                if (playType == true)
                {
                    HideObjByDJ();
                }
                else
                {
                    HideObjBylist();
                }

                if(reverse)
                if (--aniState < 0 )
                {
                    aniState = menuList.Count - 1;

                    if (num % 2 != 0)
                        runListIndex++;
                    num++;
                }

                if (!reverse)
                if (++aniState > menuList.Count - 1)
                {
                    aniState = 0;

                    if (num % 2 != 0)
                        runListIndex++;
                    num++;
                }
                aniMenuItem = menuList[aniState];
            }

            yield return new WaitForEndOfFrame();
        }
        SetFinishedState();
        finishedCallBack?.Invoke();

    }

    private void PlayByDJ()
    {
        if (reverse)
            lerp = (1 - timer / aniMenuItem.duration);
        else
            lerp = timer / aniMenuItem.duration;

        if (aniMenuItem.localMovePos != Vector3.zero && aniMenuItem.duration >0)
        {
            if (num % 2 != 0)
            {

                aniMenuItem.objList[runListIndex + objListCount / 4].SetActive(true);
                aniMenuItem.objList[runListIndex + 3 * objListCount / 4].SetActive(true);

                aniMenuItem.objList[runListIndex + objListCount / 4].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex + objListCount / 4].transform.position, aniMenuItem.tmpList[runListIndex + objListCount / 4].transform.position + aniMenuItem.tmpList[runListIndex + objListCount / 4].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex + objListCount / 4].transform.rotation = aniMenuItem.tmpList[runListIndex + objListCount / 4].transform.rotation;
                aniMenuItem.objList[runListIndex + objListCount / 4].transform.RotateAround(aniMenuItem.tmpList[runListIndex + objListCount / 4].transform.position, aniMenuItem.tmpList[runListIndex + objListCount / 4].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);

                aniMenuItem.objList[runListIndex + 3 * objListCount / 4].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex + 3 * objListCount / 4].transform.position, aniMenuItem.tmpList[runListIndex + 3 * objListCount / 4].transform.position + aniMenuItem.tmpList[runListIndex + 3 * objListCount / 4].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex + 3 * objListCount / 4].transform.rotation = aniMenuItem.tmpList[runListIndex + 3 * objListCount / 4].transform.rotation;
                aniMenuItem.objList[runListIndex + 3 * objListCount / 4].transform.RotateAround(aniMenuItem.tmpList[runListIndex + 3 * objListCount / 4].transform.position, aniMenuItem.tmpList[runListIndex + 3 * objListCount / 4].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);

            }
            else
            {
                aniMenuItem.objList[runListIndex].SetActive(true);
                aniMenuItem.objList[runListIndex + objListCount / 2].SetActive(true);

                aniMenuItem.objList[runListIndex].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex].transform.position, aniMenuItem.tmpList[runListIndex].transform.position + aniMenuItem.tmpList[runListIndex].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex].transform.rotation = aniMenuItem.tmpList[runListIndex].transform.rotation;
                aniMenuItem.objList[runListIndex].transform.RotateAround(aniMenuItem.tmpList[runListIndex].transform.position, aniMenuItem.tmpList[runListIndex].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);

                aniMenuItem.objList[runListIndex + objListCount / 2].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex + objListCount / 2].transform.position, aniMenuItem.tmpList[runListIndex + objListCount / 2].transform.position + aniMenuItem.tmpList[runListIndex + objListCount / 2].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex + objListCount / 2].transform.rotation = aniMenuItem.tmpList[runListIndex + objListCount / 2].transform.rotation;
                aniMenuItem.objList[runListIndex + objListCount / 2].transform.RotateAround(aniMenuItem.tmpList[runListIndex + objListCount / 2].transform.position, aniMenuItem.tmpList[runListIndex].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);
}
        }
    }

    public void HideObjByDJ()
    {
        if (num % 2 != 0)
        {

            aniMenuItem.objList[runListIndex + objListCount / 4].SetActive(reverse);
            aniMenuItem.objList[runListIndex + 3 * objListCount / 4].SetActive(reverse);
        }
        else
        {
            aniMenuItem.objList[runListIndex].SetActive(reverse);
            aniMenuItem.objList[runListIndex + objListCount / 2].SetActive(reverse);
        }
    }

    public void HideObjBylist()
    {
        if (num % 2 != 0)
        {
            aniMenuItem.objList[runListIndex * 4 + 2].SetActive(reverse);
            aniMenuItem.objList[runListIndex * 4 + 3].SetActive(reverse);
        }
        else
        {
            aniMenuItem.objList[runListIndex * 4].SetActive(reverse);
            aniMenuItem.objList[runListIndex * 4 + 1].SetActive(reverse);

        }
    }

    private void PlayByList()
    {
        if (reverse)
            lerp = (1 - timer / aniMenuItem.duration);
        else
            lerp = timer / aniMenuItem.duration;

        if (aniMenuItem.localMovePos != Vector3.zero && aniMenuItem.duration > 0)
        {
            if (num % 2 != 0)
            {
                aniMenuItem.objList[runListIndex * 4 + 2].SetActive(true);
                aniMenuItem.objList[runListIndex * 4 + 3].SetActive(true);

                aniMenuItem.objList[runListIndex * 4 + 2].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex * 4 + 2].transform.position, aniMenuItem.tmpList[runListIndex * 4 + 2].transform.position + aniMenuItem.tmpList[runListIndex * 4 + 2].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex * 4 + 2].transform.rotation = aniMenuItem.tmpList[runListIndex * 4 + 2].transform.rotation;
                aniMenuItem.objList[runListIndex * 4 + 2].transform.RotateAround(aniMenuItem.tmpList[runListIndex * 4 + 2].transform.position, aniMenuItem.tmpList[runListIndex * 4 + 2].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);

                aniMenuItem.objList[runListIndex * 4 + 3].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex * 4 + 3].transform.position, aniMenuItem.tmpList[runListIndex * 4 + 3].transform.position + aniMenuItem.tmpList[runListIndex * 4 + 3].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex * 4 + 3].transform.rotation = aniMenuItem.tmpList[runListIndex * 4 + 3].transform.rotation;
                aniMenuItem.objList[runListIndex * 4 + 3].transform.RotateAround(aniMenuItem.tmpList[runListIndex * 4 + 3].transform.position, aniMenuItem.tmpList[runListIndex * 4 + 3].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);

            }
            else
            {
                aniMenuItem.objList[runListIndex * 4].SetActive(true);
                aniMenuItem.objList[runListIndex * 4 + 1].SetActive(true);

                aniMenuItem.objList[runListIndex * 4].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex * 4].transform.position, aniMenuItem.tmpList[runListIndex * 4].transform.position + aniMenuItem.tmpList[runListIndex * 4].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex * 4].transform.rotation = aniMenuItem.tmpList[runListIndex * 4].transform.rotation;
                aniMenuItem.objList[runListIndex * 4].transform.RotateAround(aniMenuItem.tmpList[runListIndex * 4].transform.position, aniMenuItem.tmpList[runListIndex * 4].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);

                aniMenuItem.objList[runListIndex * 4 + 1].transform.position = Vector3.Lerp(aniMenuItem.tmpList[runListIndex * 4 + 1].transform.position, aniMenuItem.tmpList[runListIndex * 4 + 1].transform.position + aniMenuItem.tmpList[runListIndex * 4 + 1].transform.TransformDirection(aniMenuItem.localMovePos), lerp);
                aniMenuItem.objList[runListIndex * 4 + 1].transform.rotation = aniMenuItem.tmpList[runListIndex * 4 + 1].transform.rotation;
                aniMenuItem.objList[runListIndex * 4 + 1].transform.RotateAround(aniMenuItem.tmpList[runListIndex * 4 + 1].transform.position, aniMenuItem.tmpList[runListIndex * 4 + 1].transform.TransformDirection(aniMenuItem.localMovePos), aniMenuItem.rotAngle * lerp);
            }
        }


    }

    [SerializeField]
    public struct LuoShuanObj
    {
        [LabelText("名称")]
        public string objName;

        

        [LabelText("对象列表")]
        public List<GameObject> objList;

        [FoldoutGroup("动画属性"), LabelText("移动方向"), HideIf("showAniInfo")]
        public Vector3 localMovePos;

        [FoldoutGroup("动画属性"), LabelText("旋转角度"), HideIf("showAniInfo")]
        public float rotAngle;

        [FoldoutGroup("动画属性"), LabelText("运行时长"), HideIf("showAniInfo")]
        public float duration;

        [LabelText("锚点列表"), HideIf("showAniInfo")]
        public List<GameObject> tmpList;

        private bool showAniInfo;

        [HideInInspector]
        public objType itemType;

        public LuoShuanObj(string objName, List<GameObject> objList, Vector3 localMovePos, float rotAngle, float duration, List<GameObject> tmpList, bool showAniInfo, objType itemType)
        {
            this.objName = objName;
            this.objList = objList;
            this.localMovePos = localMovePos;
            this.rotAngle = rotAngle;
            this.duration = duration;
            this.tmpList = tmpList;
            this.showAniInfo = showAniInfo;
            this.itemType = itemType;
        }
    }


}