XiuXianGame/Assets/Scripts/GameUI/UI/ShowItemMoveTarget/ShowItemMoveToTargetPanel.cs

using System.Collections.Generic;
using CombatLibrary.CombatLibrary.CombatCore.Utility;
using Common.Utility.CombatEvent;
using Fort23.Core;
using Fort23.UTool;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Logical;
using UnityEngine;
using UnityEngine.UI;
using Utility.UITool;

namespace Fort23.Mono
{
    [UIBinding(prefab = "ShowItemMoveToTargetPanel")]
    public partial class ShowItemMoveToTargetPanel : UIPanel
    {
        protected List<ImageMove> allImageMove = new List<ImageMove>();

        public static async CTask OpenShowItemMoveToTargetPanel()
        {
            ShowItemMoveToTargetPanel showItemMoveToTargetPanel =
                await UIManager.Instance.LoadAndOpenPanel<ShowItemMoveToTargetPanel>(null, UILayer.Middle,
                    isFocus: false);
        }

        public static async void OpenShowItemMoveToTargetPanel(Vector2 startPos, Vector2 target,
            bool isStartPosUseWorld, bool isEndPosUseWorld,
            List<string> allItem)
        {
            ShowItemMoveToTargetPanel showItemMoveToTargetPanel =
                await UIManager.Instance.LoadAndOpenPanel<ShowItemMoveToTargetPanel>(null, UILayer.Top, isFocus: false);
            if (isStartPosUseWorld)
            {
                startPos = showItemMoveToTargetPanel.transform.worldToLocalMatrix * startPos;
            }

            if (isEndPosUseWorld)
            {
                target = showItemMoveToTargetPanel.transform.worldToLocalMatrix * target;
            }

            showItemMoveToTargetPanel.ShowPanel(startPos, target, allItem.Count, "");
        }

        public static async void OpenShowItemMoveToTargetPanel(List<string> allItem)
        {
            ShowItemMoveToTargetPanel showItemMoveToTargetPanel =
                await UIManager.Instance.LoadAndOpenPanel<ShowItemMoveToTargetPanel>(null, UILayer.Top, isFocus: false);
            Vector2 target = showItemMoveToTargetPanel.moveTarget.GetComponent<RectTransform>().anchoredPosition;
            showItemMoveToTargetPanel.moveTarget.gameObject.SetActive(true);
            showItemMoveToTargetPanel.ShowPanel(new Vector2(), target, allItem.Count, "");
        }

        public static async void OpenShowItemMoveToTargetPanel(Vector2 startPos, Vector2 target, List<string> allItem)
        {
            ShowItemMoveToTargetPanel showItemMoveToTargetPanel =
                await UIManager.Instance.LoadAndOpenPanel<ShowItemMoveToTargetPanel>(null, UILayer.Top, isFocus: false);
            showItemMoveToTargetPanel.ShowPanel(startPos, target, allItem.Count, "");
        }

        private void Init()
        {
        }

        protected override void AddEvent()
        {
            StaticUpdater.Instance.AddRenderUpdateCallBack(RenderUpdateCallBack);
            EventManager.Instance.AddEventListener(CustomEventType.Combat_ItemShow, Combat_ItemShow);
        }

        protected override void DelEvent()
        {
            StaticUpdater.Instance.RemoveRenderUpdateCallBack(RenderUpdateCallBack);
            EventManager.Instance.RemoveEventListener(CustomEventType.Combat_ItemShow, Combat_ItemShow);
        }

        public override void AddButtonEvent()
        {
        }

        protected void Combat_ItemShow(IEventData iEventData)
        {
            Vector2 target = moveTarget.GetComponent<RectTransform>().anchoredPosition;
            CombatItemShowEventData combatItemShowEventData = iEventData as CombatItemShowEventData;
            bool isExp = combatItemShowEventData.isExp;
            if (isExp)
            {
                MainUIPanel mainUIPanel = UIManager.Instance.GetComponent<MainUIPanel>();
                Vector3 pos = mainUIPanel.expPoint.position;
                target = transform.worldToLocalMatrix * pos;
            }

            Vector3 p = UIManager.Instance.CurrCustomCameraStack.camera.WorldToScreenPoint(
                combatItemShowEventData.startPos_WorldPos);
            Vector3 p2 = UIManager.Instance.UICamera.ScreenToWorldPoint(p);
            Vector3 startPos = transform.worldToLocalMatrix * p2;
            ShowPanel(startPos, target, combatItemShowEventData.count, combatItemShowEventData.showName, delegate
            {
                MainUIPanel mainUIPanel = UIManager.Instance.GetComponent<MainUIPanel>();
                if (mainUIPanel == null)
                {
                    return;
                }

                if (isExp)
                {
                    if (mainUIPanel != null)
                    {
                        ParticleSystemPool particleSystemPool =
                            GObjectPool.Instance.FetchAsyncForGameObject<ParticleSystemPool>(mainUIPanel.fx_ui_exp,
                                "fx_ui_exp");
                        particleSystemPool.transform.SetParent(mainUIPanel.expPoint.transform);
                        particleSystemPool.transform.localPosition = Vector3.zero;
                        particleSystemPool.transform.localScale = Vector3.one;
                        // particleSystemPool.transform.
                    }
                }
                else
                {
                    if (mainUIPanel != null)
                    {
                        ParticleSystemPool particleSystemPool =
                            GObjectPool.Instance.FetchAsyncForGameObject<ParticleSystemPool>(mainUIPanel.fx_ui_coin,
                                "fx_ui_coin");
                        particleSystemPool.transform.SetParent(mainUIPanel.Icon_Coin.transform);
                        particleSystemPool.transform.localPosition = Vector3.zero;
                        particleSystemPool.transform.localScale = Vector3.one;
                        // particleSystemPool.transform.
                    }
                }
            });
        }

        protected void RenderUpdateCallBack()
        {
            for (int i = 0; i < allImageMove.Count; i++)
            {
                ImageMove imageMove = allImageMove[i];
                if (imageMove.Update())
                {
                    GObjectPool.Instance.Recycle(imageMove.GameObjectPool);
                    allImageMove.RemoveAt(i);
                    i--;
                }
            }

            if (allImageMove.Count <= 0)
            {
                moveTarget.gameObject.SetActive(false);
            }
        }

        public void AddACurve(Vector2 startPos, Vector2 target, string itemConfig, System.Action finishCallBack)
        {
            ACurve aCurve = new ACurve();
            CurveInfo curveInfo = new CurveInfo();
            // Vector3 p = startPos + (startPos - target).normalized * 30;
            Vector3 moveTargetPos = startPos + new Vector2(Random.Range(-50, 50),
                Random.Range(-50, 50));

            Vector2 newStartPos = moveTargetPos;

            curveInfo.t = newStartPos.x;
            curveInfo.v = newStartPos.y;
            curveInfo.BSLt = 0;
            // float x = Random.Range(-10, 10) * 30;
            Vector2 normal = (newStartPos - target).normalized;
            int x = Random.Range(0, 100) < 50 ? 1 : -1;
            normal = new Vector2(normal.y, -normal.x) * x * 300 + newStartPos;
            normal = (normal - target).normalized * 500;

            curveInfo.it = normal.x + curveInfo.t;
            curveInfo.ot = normal.y + curveInfo.v;
            CurveInfo curveInfo2 = new CurveInfo();
            curveInfo2.t = target.x;
            curveInfo2.v = target.y;
            Vector3 normal2 = (newStartPos - target).normalized;
            curveInfo2.it = normal2.x + curveInfo2.t;
            curveInfo2.ot = normal2.y + curveInfo2.v + 10;
            curveInfo2.BSLt = 1;
            aCurve.CurveInfos = new List<CurveInfo>();
            aCurve.CurveInfos.Add(curveInfo);
            aCurve.CurveInfos.Add(curveInfo2);
            aCurve.CurveType = CurveType.BSL;
            ImageMove currImageMove = new ImageMove();
            currImageMove.finishCallBack = finishCallBack;
            currImageMove.SizeCurve = AnimationCurveManager.Instance.AnimationCurveLibrary.ui_moveSize;
            currImageMove.moveSpeed = AnimationCurveManager.Instance.AnimationCurveLibrary.ui_moveSpped;
            // currImageMove.ShowSizeCurve = AnimationCurveManager.Instance.AnimationCurveLibrary.ui_showSize;
            // currImageMove.showSizeSpeed = 10;
            GameObjectPool gameObjectPool =
                GObjectPool.Instance.FetchAsyncForGameObject<GameObjectPool>(moveIcon.gameObject, "moveIcon");
            gameObjectPool.own.transform.SetParent(transform);
            gameObjectPool.own.SetActive(false);
            gameObjectPool.own.transform.localScale = Vector3.zero;
            currImageMove.GameObjectPool = gameObjectPool;
            MyImage myImage = gameObjectPool.own.GetComponent<MyImage>();
            myImage.onSpriteAlter = delegate { myImage.SetNativeSize(); };
            myImage.icon_name = itemConfig;
            currImageMove.transform = gameObjectPool.own.GetComponent<RectTransform>();
            // currImageMove.transform.sizeDelta = new Vector2(35, 35);
            currImageMove.moveStartPos = startPos;
            currImageMove.moveTargetPos = moveTargetPos;
            currImageMove.transform.anchoredPosition = currImageMove.moveStartPos;
            currImageMove.yanChi = Random.Range(0, 0.5f);
            currImageMove.speed = AnimationCurveManager.Instance.AnimationCurveLibrary.uiMoveSpeed;
            currImageMove.currAcur = aCurve;
            allImageMove.Add(currImageMove);
        }

        public void ShowPanel(Vector2 startPos, Vector2 target, int count, string showName,
            System.Action finishCallBack = null)
        {
            if (target.x == -5000)
            {
                target = moveTarget.GetComponent<RectTransform>().anchoredPosition;
            }

            for (int i = 0; i < count; i++)
            {
                AddACurve(startPos, target, showName, finishCallBack);
            }
        }
    }
}