XiuXianGame/Assets/Scripts/GameUI/UI/CombatPanel/SkillSelectPanel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Core.Audio;
using Core.Event.Event;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat;
using GameLogic.Combat.CombatTool;
using GameLogic.Hero;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace Fort23.Mono
{
    [UIBinding(prefab = "SkillSelectPanel")]
    public partial class SkillSelectPanel : UIPanel, IScrollListContent
    {
        private bool _isSelectSkill;
        public List<SkillKongWidget> allKongSkill = new List<SkillKongWidget>();
        List<WuXingGongFaWidget> _wuXingGongFaWidgets = new List<WuXingGongFaWidget>();
        private SkillInfo selectSkillConfig;
        private bool isAlter;

        private int type1 = 0;
        private int type2 = 0;

        public SkillInfo[] allUseSkill;

        private int currenRoadSkilId;

        /// <summary>
        /// 1.执行升级逻辑 2.执行更换逻辑
        /// </summary>
        private int infoType = 1;

        SkillInfo currentSelectedSkill;

        public static async CTask<SkillSelectPanel> OpenSkillSelectPanel()
        {
            CombatDrive.Instance.CombatController.isUpdate = false;
            SkillSelectPanel skillSelectPanel =
                await UIManager.Instance.LoadAndOpenPanel<SkillSelectPanel>(null, UILayer.Middle);
            return skillSelectPanel;
        }

        public async override CTask GetFocus()
        {
            if (infoType == 1)
            {
                await AppBarPanel.OpenPanel(this);
            }
            else if (infoType == 2)
            {
                AppBarPanel.ClosePanel();
            }

            TitlePanel.ClosePanel();
            // AppBarPanel.OpenPanel(this);
            await base.GetFocus();
        }

        public override CTask LoseFocus()
        {
            // AppBarPanel.ClosePanel();
            return base.LoseFocus();
        }

        private void Init()
        {
            isAddStack = true;
            IsShowAppBar = true;
        }

        protected override void AddEvent()
        {
            // EventManager.Instance.AddEventListener(CustomEventType.SkillBeginDrag, SkillBeginDragHandle);
            // EventManager.Instance.AddEventListener(CustomEventType.SkillDrag, SkillDragHandle);
            // EventManager.Instance.AddEventListener(CustomEventType.SkillEndDrag, SkillEndDragHandle);
        }


        protected override void DelEvent()
        {
            // EventManager.Instance.RemoveEventListener(CustomEventType.SkillBeginDrag, SkillBeginDragHandle);
            // EventManager.Instance.RemoveEventListener(CustomEventType.SkillDrag, SkillDragHandle);
            // EventManager.Instance.RemoveEventListener(CustomEventType.SkillEndDrag, SkillEndDragHandle);
        }

        public override CTask<bool> AsyncInit(object[] uiData)
        {
            if (PlayerGuideManager.Instance.GuideIsCanDo(4, 1))
            {
                PlayerGuideManager.Instance.NextGuide();
            }

            allUseSkill = PlayerManager.Instance.GongFaControl.allUseSkill.ToArray();
            currenRoadSkilId = PlayerManager.Instance.myHero.TaoismSkillId;
            UpdateSkillWidget();
            UpdateRoad();

            // CloseSelect();
            return base.AsyncInit(uiData);
        }

        public override void AddButtonEvent()
        {
            Btn_OneKyChange.onClick.AddListener(() =>
            {
                for (var i = 0; i < allUseSkill.Length; i++)
                {
                    allUseSkill[i] = null;
                }

                SkillInfo[] skills = new SkillInfo[5];
                List<SkillInfo> allSkill = PlayerManager.Instance.GongFaControl.allSkill.ToList();

                for (var i = 0; i < allSkill.Count; i++)
                {
                    //金
                    if (allSkill[i].skillConfig.attribute == 1)
                    {
                        if (skills[0] == null || skills[0].skillConfig.level > allSkill[i].skillConfig.level)
                        {
                            skills[0] = allSkill[i];
                        }
                    }

                    //木
                    if (allSkill[i].skillConfig.attribute == 2)
                    {
                        if (skills[1] == null || skills[1].skillConfig.level > allSkill[i].skillConfig.level)
                        {
                            skills[1] = allSkill[i];
                        }
                    }

                    //水
                    if (allSkill[i].skillConfig.attribute == 4)
                    {
                        if (skills[2] == null || skills[2].skillConfig.level > allSkill[i].skillConfig.level)
                        {
                            skills[2] = allSkill[i];
                        }
                    }

                    //火
                    if (allSkill[i].skillConfig.attribute == 8)
                    {
                        if (skills[3] == null || skills[3].skillConfig.level > allSkill[i].skillConfig.level)
                        {
                            skills[3] = allSkill[i];
                        }
                    }

                    //土
                    if (allSkill[i].skillConfig.attribute == 16)
                    {
                        if (skills[4] == null || skills[4].skillConfig.level > allSkill[i].skillConfig.level)
                        {
                            skills[4] = allSkill[i];
                        }
                    }
                }

                for (var i = 0; i < allKongSkill.Count; i++)
                {
                    allKongSkill[i].InitWidget(allKongSkill[i].index, this);
                }

                for (var i = 0; i < indexList.Count; i++)
                {
                    if (skills[i] == null)
                        continue;
                    if (!IsMainGongFaChange(skills[i].skillConfig))
                        continue;

                    if (!IsPassiveGongFaChange(skills[i].skillConfig))
                        continue;
                    allKongSkill[indexList[i][0]].SetSKill(skills[i]);
                    allUseSkill[indexList[i][0]] = skills[i];
                }

                isAlter = true;

                UpdateSkillWidget();
                BaoChun();
            });

            Btn_ChangeOk.onClick.AddListener(() =>
            {
                ChangeInfoType(1);
                if (isAlter)
                {
                    PlayerManager.Instance.GongFaControl.SaveUseSkill(allUseSkill);

                    PlayerManager.Instance.GongFaControl.SetTaoismSkillIndex(currenRoadSkilId);
                    PlayerManager.Instance.myHero.heroData.TaoismSkillId = currenRoadSkilId;
                    AccountFileInfo.Instance.SavePlayerData();
                }

                isAlter = false;
            });

            Btn_Info.onClick.AddListener(async () =>
            {
                if (currentSelectedSkill != null)
                {
                    GongFaUpgradePanel gongFaUpgradePanel = await GongFaUpgradePanel.Open(currentSelectedSkill);
                    await gongFaUpgradePanel.UIClosed();
                    Sort(type1, type2);
                }
            });

            Btn_ChangeRoad.onClick.AddListener(() =>
            {
                SkillRoadSelecPanel.OpenPanel(currenRoadSkilId, (skillId) =>
                {
                    if (skillId != currenRoadSkilId && skillId != 0)
                    {
                        currenRoadSkilId = skillId;
                        isAlter = true;
                        UpdateRoad();
                    }
                });
            });

            Btn_Setting.onClick.AddListener(() =>
            {
                ChangeInfoType(2);
                if (PlayerGuideManager.Instance.GuideIsCanDo(4, 4))
                {
                    PlayerGuideManager.Instance.NextGuide();
                }
            });

            Btn_Jin.onClick.AddListener(() =>
            {
                if (type2 == 1)
                {
                    type2 = 0;
                }
                else
                {
                    type2 = 1;
                }

                Sort(type1, type2);
            });
            Btn_Mu.onClick.AddListener(() =>
            {
                if (type2 == 2)
                {
                    type2 = 0;
                }
                else
                {
                    type2 = 2;
                }

                Sort(type1, type2);
            });
            Btn_Shui.onClick.AddListener(() =>
            {
                if (type2 == 4)
                {
                    type2 = 0;
                }
                else
                {
                    type2 = 4;
                }

                Sort(type1, type2);
            });
            Btn_Huo.onClick.AddListener(() =>
            {
                if (type2 == 8)
                {
                    type2 = 0;
                }
                else
                {
                    type2 = 8;
                }

                Sort(type1, type2);
            });
            Btn_Tu.onClick.AddListener(() =>
            {
                if (type2 == 16)
                {
                    type2 = 0;
                }
                else
                {
                    type2 = 16;
                }

                Sort(type1, type2);
            });

            Btn_All.onClick.AddListener(() =>
            {
                type1 = 0;

                Sort(type1, type2);
            });
            Btn_ZhuDong.onClick.AddListener(() =>
            {
                type1 = 1;
                Sort(type1, type2);
            });
            Btn_FuZu.onClick.AddListener(() =>
            {
                type1 = 2;
                Sort(type1, type2);
            });
            Btn_BeiDong.onClick.AddListener(() =>
            {
                type1 = 5;
                Sort(type1, type2);
            });

            guanbi.onClick.AddListener(() =>
            {
                if (PlayerGuideManager.Instance.GuideIsCanDo(4, 8))
                {
                    PlayerGuideManager.Instance.NextGuide();
                }

                if (infoType == 2)
                {
                    ChangeInfoType(1);
                    currenRoadSkilId = PlayerManager.Instance.myHero.TaoismSkillId;
                    allUseSkill = PlayerManager.Instance.GongFaControl.allUseSkill.ToArray();
                    for (var i = 0; i < allKongSkill.Count; i++)
                    {
                        allKongSkill[i].InitWidget(allKongSkill[i].index, this);
                        allKongSkill[i].SetSKill(allUseSkill[allKongSkill[i].index]);
                    }

                    UpdateSkillWidget();
                    UpdateRoad();
                }
                else
                {
                    // UIManager.Instance.HideUIUIPanel(this);
                }

                AudioManager.Instance.PlayAudio("ui_fanhui.wav");
            });
            Btn_RemoveGongFa.onClick.AddListener(() =>
            {
                // PlayerManager.Instance.GongFaControl.RemoveSkillInfo(dianjiSkillKongWidget.index);
                allUseSkill[dianjiSkillKongWidget.index] = null;
                dianjiSkillKongWidget.Cleared();
                isAlter = true;
                UpdateSkillWidget();
                CloseSelect();
                BaoChun();
                showSkillInfo.Sort(Sort);
                Content.Init(this, showSkillInfo.Count);
                AudioManager.Instance.PlayAudio("ui_xiazhenggongfa.wav");
            });

            Sv.onValueChanged.AddListener((s) =>
            {
                if (currentSelectedSkill == null)
                {
                    return;
                }

                Btn_Info.transform.SetAsLastSibling();
            });
        }

        private bool isDraging = false;

        //拖动得技能
        private SkillKongWidget nowSkillKongWidget;

        //进入的技能
        private SkillKongWidget nowInSkillKongWidget;

        //拖动中技能
        private SkillKongWidget nowSkillKongWidget1;
        // private Image _image;

        private async void SkillBeginDragHandle(PointerEventData pointerEventData, ItemWidgetBasic itemWidgetBasic)
        {
            LogTool.Log("开始拖动");

            if (infoType == 1)
            {
                return;
            }

            if (dianjiSkillKongWidget != null)
            {
                return;
            }


            SkillKongWidget skillKongWidget1 = itemWidgetBasic as SkillKongWidget;
            if (skillKongWidget1.SkillInfo == null)
                return;


            isDraging = true;
            //记录当前选中的格子
            nowSkillKongWidget = skillKongWidget1;

            nowSkillKongWidget.Translucency();
            dianjiSkillKongWidget = skillKongWidget1;
            SelectSkill(nowSkillKongWidget.SkillInfo, false, false);


            nowSkillKongWidget1 = await UIManager.Instance.CreateGComponentForObject<SkillKongWidget>(
                SkillKongWidget1game.gameObject,
                null, transform.GetComponent<RectTransform>(), uiData: new object[] { false,false },
                isInstance: false);
            nowSkillKongWidget1.own.SetActive(true);
            nowSkillKongWidget1.InitWidget(nowSkillKongWidget.index, this);
            nowSkillKongWidget1.SetSKill(skillKongWidget1.SkillInfo);
        }

        private void SkillDragHandle(PointerEventData pointerEventData, ItemWidgetBasic itemWidgetBasic)
        {
            LogTool.Log("拖动中");

            if (nowSkillKongWidget1 == null)
                return;
            Vector2 localPos;

            RectTransformUtility.ScreenPointToLocalPointInRectangle(
                transform.GetComponent<RectTransform>(),
                pointerEventData.position,
                pointerEventData.pressEventCamera,
                out localPos);
            nowSkillKongWidget1.transform.localPosition = localPos;
        }

        private void SkillEndDragHandle(PointerEventData pointerEventData, ItemWidgetBasic itemWidgetBasic)
        {
            LogTool.Log("结束拖动");
            isDraging = false;
            nowSkillKongWidget?.Opaque();
            if (nowInSkillKongWidget == null)
            {
                CloseSelect();
            }

            nowInSkillKongWidget?.OnPointerClick();
            nowSkillKongWidget = null;
            if (nowInSkillKongWidget != null)
            {
                nowInSkillKongWidget.transform.localScale = Vector3.one;
            }

            nowInSkillKongWidget = null;


            if (nowSkillKongWidget1 == null)
                return;
            nowSkillKongWidget1.own.SetActive(false);
            nowSkillKongWidget1 = null;
        }

        private void SkillPointEnterHandle(ItemWidgetBasic itemWidgetBasic)
        {
            LogTool.Log("进入");

            if (isDraging)
            {
                nowInSkillKongWidget = itemWidgetBasic as SkillKongWidget;
                nowInSkillKongWidget.transform.localScale = Vector3.one * 1.1f;
                return;
            }
        }


        private void SkillPointExitHandle(ItemWidgetBasic itemWidgetBasic)
        {
            LogTool.Log("离开");
            if (isDraging)
            {
                if (nowInSkillKongWidget != null)
                    nowInSkillKongWidget.transform.localScale = Vector3.one;
                nowInSkillKongWidget = null;
                return;
            }
        }


        private void UpdateRoad()
        {
            if (currenRoadSkilId != 0)
            {
                SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(currenRoadSkilId);
                Text_RoadName.text = LanguageManager.Instance.Text(skillConfig.name);
            }
            else
            {
                Text_RoadName.text = "未选择";
            }
            // 
        }

        private void BaoChun()
        {
            // ChangeInfoType(1);
            // if (isAlter)
            {
                PlayerManager.Instance.GongFaControl.SaveUseSkill(allUseSkill);

                PlayerManager.Instance.GongFaControl.SetTaoismSkillIndex(currenRoadSkilId);
                PlayerManager.Instance.myHero.heroData.TaoismSkillId = currenRoadSkilId;
                AccountFileInfo.Instance.SavePlayerData();
            }

            isAlter = false;
        }

        private void ChangeInfoType(int type)
        {
            if (type == 1)
            {
                GongFaSettingRoot.SetActive(false);
                infoType = 1;
                Btn_Setting.gameObject.SetActive(true);
                CloseSelect();
                AppBarPanel.OpenPanel(this);
                Text_FuZhuGongFaCount.transform.parent.gameObject.SetActive(false);
            }
            else if (type == 2)
            {
                GongFaSettingRoot.SetActive(true);
                infoType = 2;
                allUseSkill = PlayerManager.Instance.GongFaControl.allUseSkill.ToArray();
                Btn_Setting.gameObject.SetActive(false);
                AppBarPanel.ClosePanel();
                Text_FuZhuGongFaCount.transform.parent.gameObject.SetActive(true);
            }
        }

        List<SkillInfo> showSkillInfo = new List<SkillInfo>();

        List<List<int>> indexList = new List<List<int>>()
        {
            new List<int>() { 0, 1, 9 }, //金
            new List<int>() { 4, 5, 3 }, //木
            new List<int>() { 2, 3, 1 }, //水
            new List<int>() { 6, 7, 5 }, //火
            new List<int>() { 8, 9, 7 }, //土
        };

        private void Sort(int type1, int type2)
        {
            //先排序类型在排属性

            if (type1 == 0)
            {
                BtnRoot.ClickWidget(Btn_All.GetComponent<UIToggleWidgetBasic>());
            }
            else if (type1 == 1)
            {
                BtnRoot.ClickWidget(Btn_ZhuDong.GetComponent<UIToggleWidgetBasic>());
            }
            else if (type1 == 2)
            {
                BtnRoot.ClickWidget(Btn_FuZu.GetComponent<UIToggleWidgetBasic>());
            }
            else if (type1 == 5)
            {
                BtnRoot.ClickWidget(Btn_BeiDong.GetComponent<UIToggleWidgetBasic>());
            }

            if (type2 == 0)
            {
                Icon_Select.gameObject.SetActive(false);
            }
            else if (type2 == 1)
            {
                Icon_Select.transform.position = Btn_Jin.transform.position;
                Icon_Select.gameObject.SetActive(true);
            }
            else if (type2 == 2)
            {
                Icon_Select.transform.position = Btn_Mu.transform.position;
                Icon_Select.gameObject.SetActive(true);
            }
            else if (type2 == 4)
            {
                Icon_Select.transform.position = Btn_Shui.transform.position;
                Icon_Select.gameObject.SetActive(true);
            }
            else if (type2 == 8)
            {
                Icon_Select.transform.position = Btn_Huo.transform.position;
                Icon_Select.gameObject.SetActive(true);
            }
            else if (type2 == 16)
            {
                Icon_Select.transform.position = Btn_Tu.transform.position;
                Icon_Select.gameObject.SetActive(true);
            }


            //0代表全部
            if (type1 == 0)
            {
                showSkillInfo = PlayerManager.Instance.GongFaControl.allSkill.ToList();
            }
            else
            {
                showSkillInfo = PlayerManager.Instance.GongFaControl.allSkill
                    .Where(s => s.skillConfig.SkillType == type1).ToList();
            }

            if (type2 == 0)
            {
            }
            else
            {
                showSkillInfo = showSkillInfo.Where(s => s.skillConfig.attribute == type2).ToList();
            }

            CloseSelect();
            showSkillInfo.Sort(Sort);
            Content.Init(this, showSkillInfo.Count);
        }

        private int Sort(SkillInfo type1, SkillInfo type2)
        {
            if (allUseSkill.Contains(type1) && !allUseSkill.Contains(type2))
            {
                return -1;
            }


            if (!allUseSkill.Contains(type1) && allUseSkill.Contains(type2))
            {
                return 1;
            }

            return type1.skillConfig.SkillType != type2.skillConfig.SkillType
                ? type1.skillConfig.SkillType.CompareTo(type2.skillConfig.SkillType)
                : type1.skillConfig.ID.CompareTo(type2.skillConfig.ID);

            return 0;
        }


        public override async CTask Open()
        {
            await base.Open();


            Sort(type1, type2);


            for (int i = 0; i < 5; i++)
            {
                double hd = i * 72 * Math.PI / 180f;
                double a = Math.Cos(hd);
                double b = -Math.Sin(hd);
                double c = Math.Sin(hd);
                double d = a;
                double x = a * 0 + b * 116;
                double y = c * 0 + d * 116;

                int index = i;
                WuXingGongFaWidget widget =
                    await UIManager.Instance.CreateGComponent<WuXingGongFaWidget>(null, root: WuXingGongFaRoot,
                        poolName: "132");
                widget.transform.anchoredPosition = new Vector2((float)x, (float)y);
                widget.ShowWidget(index);
                widget.transform.localScale = new Vector3(1.8f, 1.8f, 1.8f);
                _wuXingGongFaWidgets.Add(widget);
            }


            for (int i = 0; i < 10; i++)
            {
                int index = i;
                double hd = (36 * i) * Math.PI / 180f;
                double a = Math.Cos(hd);
                double b = -Math.Sin(hd);
                double c = Math.Sin(hd);
                double d = a;
                double x = a * 0 + b * 190;
                double y = c * 0 + d * 190;
                Vector2 pos = new Vector2((float)x, (float)y);
                SkillKongWidget skillKongWidget = await UIManager.Instance.CreateGComponentForObject<SkillKongWidget>(
                    kongdongs.gameObject,
                    null, SkillKongWeiRoot, uiData: new object[] { true,true },
                    isInstance: true);
                skillKongWidget.InitWidget(index, this);
                skillKongWidget.SetSKill(allUseSkill[index]);
                skillKongWidget.transform.anchoredPosition = pos;
                skillKongWidget.OnClick = OnClickSkillKongWidget;

                skillKongWidget.onDragStart = SkillBeginDragHandle;
                skillKongWidget.onDrag = SkillDragHandle;
                skillKongWidget.onDragEnd = SkillEndDragHandle;

                skillKongWidget.onPointerEnter = SkillPointEnterHandle;

                skillKongWidget.onPointerExit = SkillPointExitHandle;

                allKongSkill.Add(skillKongWidget);
            }


            ChangeFuZhuYingXiang();
        }


        private SkillKongWidget dianjiSkillKongWidget;

        private async void OnClickSkillKongWidget(ItemWidgetBasic obj)
        {
            if (PlayerGuideManager.Instance.GuideIsCanDo(4, 7))
            {
                PlayerGuideManager.Instance.NextGuide();
            }

            SkillKongWidget skillKongWidget = obj as SkillKongWidget;
            if (infoType == 1)
            {
                if (skillKongWidget.SkillInfo == null)
                    return;

                GongFaUpgradePanel gongFaUpgradePanel = await GongFaUpgradePanel.Open(skillKongWidget.SkillInfo);
                await gongFaUpgradePanel.UIClosed();
                Sort(type1, type2);
                return;
            }

            Btn_Info.transform.SetParent(transform);
            Btn_Info.gameObject.SetActive(false);
            currentSelectedSkill = skillKongWidget.SkillInfo;

            // SkillKongWidget skillKongWidget = obj as SkillKongWidget;

            if (skillKongWidget.SkillInfo == null && dianjiSkillKongWidget == null && selectSkillConfig == null)
            {
                return;
            }


            //直接上功法
            if (skillKongWidget.SkillInfo == null && dianjiSkillKongWidget == null && selectSkillConfig != null)
            {
                if (selectSkillConfig.skillConfig.SkillType == 1)
                {
                    if (!IsMainGongFaChange(selectSkillConfig.skillConfig))
                    {
                        TipMessagePanel.OpenTipMessagePanel("主动功法已经上满");
                        CloseSelect();
                        return;
                    }
                }

                if (selectSkillConfig.skillConfig.SkillType == 2)
                {
                    if (!IsPassiveGongFaChange(selectSkillConfig.skillConfig))
                    {
                        TipMessagePanel.OpenTipMessagePanel("被动功法已经上满");
                        CloseSelect();
                        return;
                    }
                }


                isAlter = true;

                skillKongWidget.SetSKill(selectSkillConfig);
                allUseSkill[skillKongWidget.index] = selectSkillConfig;
                if (selectSkillConfig.skillConfig.SkillType == 1)
                {
                    AudioManager.Instance.PlayAudio("ui_xiazhenggongfa.wav");
                }
                else if (selectSkillConfig.skillConfig.SkillType == 2)
                {
                    AudioManager.Instance.PlayAudio("ui_fzgf_yx.wav");
                }

                CloseSelect();
                BaoChun();


                showSkillInfo.Sort(Sort);
                Content.Init(this, showSkillInfo.Count);
            }
            //替换功法
            else if (skillKongWidget.SkillInfo != null && dianjiSkillKongWidget == null && selectSkillConfig != null)
            {
                if (!IsPassiveGongFaChange(selectSkillConfig.skillConfig) &&
                    allUseSkill[skillKongWidget.SkillInfo.index].skillConfig.SkillType != 2)
                {
                    TipMessagePanel.OpenTipMessagePanel("被动功法已经上满");
                    CloseSelect();
                    return;
                }

                if (!IsMainGongFaChange(selectSkillConfig.skillConfig) &&
                    allUseSkill[skillKongWidget.SkillInfo.index].skillConfig.SkillType != 1)
                {
                    TipMessagePanel.OpenTipMessagePanel("主动功法已经上满");
                    CloseSelect();
                    return;
                }


                isAlter = true;
                allUseSkill[skillKongWidget.SkillInfo.index] = null;
                skillKongWidget.SetSKill(selectSkillConfig);
                allUseSkill[skillKongWidget.index] = selectSkillConfig;
                skillKongWidget.SetSKill(selectSkillConfig);
                if (selectSkillConfig.skillConfig.SkillType == 1)
                {
                    AudioManager.Instance.PlayAudio("ui_xiazhenggongfa.wav");
                }
                else if (selectSkillConfig.skillConfig.SkillType == 2)
                {
                    AudioManager.Instance.PlayAudio("ui_fzgf_yx.wav");
                }

                CloseSelect();
                BaoChun();
                showSkillInfo.Sort(Sort);
                Content.Init(this, showSkillInfo.Count);
            }
            else
            {
                if (dianjiSkillKongWidget != null && dianjiSkillKongWidget == skillKongWidget)
                {
                    CloseSelect();
                    return;
                }

                //交换功法

                if (dianjiSkillKongWidget == null)
                {
                    dianjiSkillKongWidget = skillKongWidget;
                    Btn_RemoveGongFa.transform.position = dianjiSkillKongWidget.RemovePos.position;
                    Btn_RemoveGongFa.gameObject.SetActive(true);
                    Btn_Info.transform.position = dianjiSkillKongWidget.InfoPos.position;
                    Btn_Info.gameObject.SetActive(true);
                    SelectSkill(skillKongWidget.SkillInfo, false, false);
                    // if (skillKongWidget.SkillInfo.skillConfig.SkillType == 1)
                    // {
                    //     AudioManager.Instance.PlayAudio("ui_xiazhenggongfa.wav");
                    // }
                    // else if (skillKongWidget.SkillInfo.skillConfig.SkillType == 2)
                    // {
                    //     AudioManager.Instance.PlayAudio("ui_fzgf_yx.wav");
                    // }
                }
                else
                {
                    isAlter = true;

                    if (skillKongWidget.SkillInfo != null)
                    {
                        dianjiSkillKongWidget.SetSKill(skillKongWidget.SkillInfo);
                        allUseSkill[dianjiSkillKongWidget.index] = dianjiSkillKongWidget.SkillInfo;
                    }
                    else
                    {
                        allUseSkill[dianjiSkillKongWidget.SkillInfo.index] = null;
                        dianjiSkillKongWidget.Cleared();
                    }

                    skillKongWidget.SetSKill(selectSkillConfig);
                    allUseSkill[skillKongWidget.index] = selectSkillConfig;
                    if (selectSkillConfig.skillConfig.SkillType == 1)
                    {
                        AudioManager.Instance.PlayAudio("ui_xiazhenggongfa.wav");
                    }
                    else if (selectSkillConfig.skillConfig.SkillType == 2)
                    {
                        AudioManager.Instance.PlayAudio("ui_fzgf_yx.wav");
                    }

                    CloseSelect();
                    BaoChun();
                }
            }

            UpdateSkillWidget();
        }


        public void SelectSkill(SkillInfo skillConfig, bool max, bool isClick)
        {
            for (int i = 0; i < allKongSkill.Count; i++)
            {
                allKongSkill[i].SelectState(false);
            }


            if (!max)
            {
                // if (isClick)
                // {
                //     int index = 0;
                //
                //     //金
                //     if (skillConfig.skillConfig.attribute == 1)
                //     {
                //         index = 0;
                //     }
                //
                //     //木
                //     if (skillConfig.skillConfig.attribute == 2)
                //     {
                //         index = 1;
                //     }
                //
                //     //水
                //     if (skillConfig.skillConfig.attribute == 4)
                //     {
                //         index = 2;
                //     }
                //
                //     //火
                //     if (skillConfig.skillConfig.attribute == 8)
                //     {
                //         index = 3;
                //     }
                //
                //     //土
                //     if (skillConfig.skillConfig.attribute == 16)
                //     {
                //         index = 4;
                //     }
                //
                //     bool isSuccess = false;
                //
                //     //先上对应位置
                //     foreach (var i in indexList[index])
                //     {
                //         if (allKongSkill[i].SkillInfo == null)
                //         {
                //             allKongSkill[i].SetSKill(skillConfig);
                //             allUseSkill[i] = skillConfig;
                //             isSuccess = true;
                //             break;
                //         }
                //     }
                //
                //     //对应位置已经上了 ，就随便找给位置上
                //     if (!isSuccess)
                //     {
                //         for (var i = 0; i < allKongSkill.Count; i++)
                //         {
                //             if (allKongSkill[i].SkillInfo == null)
                //             {
                //                 allKongSkill[i].SetSKill(skillConfig);
                //                 allUseSkill[i] = skillConfig;
                //                 break;
                //             }
                //         }
                //     }
                //
                //     if (isSuccess)
                //     {
                //         BaoChun();
                //         ChangeFuZhuYingXiang();
                //         UpdateSkillWidget();
                //         showSkillInfo.Sort(Sort);
                //         Content.Init(this, showSkillInfo.Count);
                //     }
                //     else
                //     {
                //         for (int i = 0; i < allKongSkill.Count; i++)
                //         {
                //             allKongSkill[i].SelectState(true);
                //         }
                //     }
                // }
                // else
                {
                    selectSkillConfig = skillConfig;
                    _isSelectSkill = true;
                    for (int i = 0; i < allKongSkill.Count; i++)
                    {
                        allKongSkill[i].SelectState(true);
                    }
                }
            }
            else
            {
                selectSkillConfig = skillConfig;
                _isSelectSkill = true;
                for (int i = 0; i < allKongSkill.Count; i++)
                {
                    if (allKongSkill[i].SkillInfo != null)
                    {
                        if (selectSkillConfig.skillConfig.SkillType == allKongSkill[i].SkillInfo.skillConfig.SkillType)
                            allKongSkill[i].SelectState(true);
                    }
                }
            }
        }

        List<int> yingxiang = new List<int>();

        private void CloseSelect()
        {
            _isSelectSkill = false;
            selectSkillConfig = null;
            dianjiSkillKongWidget = null;
            Btn_RemoveGongFa.gameObject.SetActive(false);

            Btn_Info.transform.SetParent(transform);
            Btn_Info.gameObject.SetActive(false);
            currentSelectedSkill = null;


            for (int i = 0; i < allKongSkill.Count; i++)
            {
                allKongSkill[i].SelectState(false);
            }

            ChangeFuZhuYingXiang();
        }

        private void ChangeFuZhuYingXiang()
        {
            yingxiang.Clear();
            float addcd = 0;
            for (int i = 0; i < allKongSkill.Count; i++)
            {
                allKongSkill[i].Icon_YingXiang.gameObject.SetActive(false);
                if (allKongSkill[i].SkillInfo != null)
                {
                    addcd += allKongSkill[i].SkillInfo.skillConfig.addcd;
                }

                if (allKongSkill[i].SkillInfo != null && allKongSkill[i].SkillInfo.skillConfig.SkillType == 2 &&
                    allKongSkill[i].SkillInfo.skillConfig.PromoteLanPara_1 != null)
                {
                    foreach (var f in allKongSkill[i].SkillInfo.skillConfig.PromoteLanPara_1)
                    {
                        if (f != 0)
                        {
                            var nubs = GetNumbers(i, f);
                            foreach (var nub in nubs)
                            {
                                if (!yingxiang.Contains(nub))
                                {
                                    yingxiang.Add(nub);
                                }
                            }
                        }
                    }
                }
            }

            foreach (var i in yingxiang)
            {
                allKongSkill[i].Icon_YingXiang.gameObject.SetActive(true);
            }

            Text_Cd.text = LanguageManager.Instance.Text(10208,
                ((PlayerManager.Instance.myHero.powerUpConfig.MaxActiveGongfaNum *
                    PlayerManager.Instance.gameConstantConfig.BasicCDperSkill / 1000) + addcd));
        }

        public List<int> GetNumbers(int start, float offset)
        {
            List<int> indexs = new List<int>();


            for (int i = 0; i < Math.Abs(offset); i++)
            {
                if (offset >= 0)
                {
                    indexs.Add(SafeMod(start + i + 1));
                }
                else
                {
                    indexs.Add(SafeMod(start - i - 1));
                }
            }

            // 确保结果在0-9范围内（循环数组）
            int SafeMod(int n) => (n % 10 + 10) % 10;
            return indexs;
        }

        public override void Hide()
        {
            base.Hide();
            CombatDrive.Instance.CombatController.isUpdate = true;
        }

        public List<SkillWidget> _skillWidgets = new List<SkillWidget>();

        public async CTask<IScorllListWidget> GetIScorllListWidget(int index, RectTransform root)
        {
            if (index < 0 || index >= showSkillInfo.Count)
                return null;
            SkillInfo skillInfo = showSkillInfo[index];
            SkillWidget skillWidget = await UIManager.Instance.CreateGComponent<SkillWidget>(null, ContentRoot);
            skillWidget.InitSkillWidget(skillInfo);
            skillWidget.OnClick = OnClick;
            if (allUseSkill.Contains(skillWidget.skillConfigId))
            {
                skillWidget.Icon_Marsk.SetActive(true);
            }
            else
            {
                skillWidget.Icon_Marsk.SetActive(false);
            }

            _skillWidgets.Add(skillWidget);
            return skillWidget;
        }

        private void UpdateSkillWidget()
        {
            foreach (var skillWidget in _skillWidgets)
            {
                if (allUseSkill.Contains(skillWidget.skillConfigId))
                {
                    skillWidget.Icon_Marsk.SetActive(true);
                }
                else
                {
                    skillWidget.Icon_Marsk.SetActive(false);
                }
            }


            Text_GongFaCount.text = LanguageManager.Instance.Text(10210, GetMainGongFaCount(),
                PlayerManager.Instance.myHero.powerUpConfig.MaxActiveGongfaNum);
            Text_FuZhuGongFaCount.text = LanguageManager.Instance.Text(10209, GetPassiveGongFaCount(),
                PlayerManager.Instance.myHero.powerUpConfig.MaxPassiveGongfaNum);
        }

        private async void OnClick(ItemWidgetBasic obj)
        {
            SkillWidget skillWidget = obj as SkillWidget;
            if (infoType == 1)
            {
                GongFaUpgradePanel gongFaUpgradePanel = await GongFaUpgradePanel.Open(skillWidget.skillConfigId);
                await gongFaUpgradePanel.UIClosed();
                Sort(type1, type2);
            }
            else if (infoType == 2)
            {
                CloseSelect();
                Btn_Info.transform.SetParent(ContentRoot);
                Btn_Info.transform.position = skillWidget.InfoPos.position;
                Btn_Info.gameObject.SetActive(true);
                currentSelectedSkill = skillWidget.skillConfigId;
                if (allUseSkill.Contains(skillWidget.skillConfigId))
                {
                    return;
                }

                Btn_RemoveGongFa.gameObject.SetActive(false);


                if (!IsMainGongFaChange(skillWidget.skillConfigId.skillConfig) ||
                    !IsPassiveGongFaChange(skillWidget.skillConfigId.skillConfig))
                {
                    SelectSkill(skillWidget.skillConfigId, true, true);
                }
                else
                {
                    SelectSkill(skillWidget.skillConfigId, false, true);
                }
            }

            if (PlayerGuideManager.Instance.GuideIsCanDo(4, 5))
            {
                PlayerGuideManager.Instance.NextGuide();
            }
        }

        /// <summary>
        /// 获得主功法数量
        /// </summary>
        /// <returns></returns>
        private int GetMainGongFaCount()
        {
            int count = 0;
            for (var i = 0; i < allUseSkill.Length; i++)
            {
                if (allUseSkill[i] != null && allUseSkill[i].skillConfig.SkillType == 1)
                {
                    count++;
                }
            }

            return count;
        }

        /// <summary>
        /// 获得被动功法数量
        /// </summary>
        /// <returns></returns>
        private int GetPassiveGongFaCount()
        {
            int count = 0;
            for (var i = 0; i < allUseSkill.Length; i++)
            {
                if (allUseSkill[i] != null && allUseSkill[i].skillConfig.SkillType == 2)
                {
                    count++;
                }
            }

            return count;
        }

        private bool IsMainGongFaChange(SkillConfig s)
        {
            if (GetMainGongFaCount() < PlayerManager.Instance.myHero.powerUpConfig.MaxActiveGongfaNum ||
                s.SkillType != 1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        private bool IsPassiveGongFaChange(SkillConfig s)
        {
            if (GetPassiveGongFaCount() < PlayerManager.Instance.myHero.powerUpConfig.MaxPassiveGongfaNum ||
                s.SkillType != 2)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public void HindIScorllListWidget(IScorllListWidget widget)
        {
            UIManager.Instance.DormancyGComponent(widget as SkillWidget);
            _skillWidgets.Remove(widget as SkillWidget);
        }

        public async override CTask Close()
        {
            foreach (var skillWidget in _skillWidgets)
            {
                UIManager.Instance.DormancyGComponent(skillWidget);
            }

            _skillWidgets.Clear();

            foreach (var skillKongWidget in allKongSkill)
            {
                // UIManager.Instance.DormancyGComponent(skillKongWidget);
            }

            allKongSkill.Clear();

            foreach (var wuXingGongFaWidget in _wuXingGongFaWidgets)
            {
                UIManager.Instance.DormancyGComponent(wuXingGongFaWidget);
            }

            Icon_Select.gameObject.SetActive(false);
            _wuXingGongFaWidgets.Clear();
            CloseSelect();
            // ChangeInfoType(1);
            await base.Close();
        }
    }
}