XiuXianGame/Assets/Scripts/GameUI/UI/DivineSence/DivineSenceInfoPanel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Core.Language;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;
using UnityEngine;
using Utility;

namespace Fort23.Mono
{
    [UIBinding(prefab = "DivineSenceInfoPanel")]
    public partial class DivineSenceInfoPanel : UIPanel
    {
        private Action<int, List<ItemInfo>> callback;

        private int useCount = 0;


        List<ItemInfo> useItems = new List<ItemInfo>();

        List<DivineSenceInfoBtnWidget> _divineSenceInfoBtnWidgets = new List<DivineSenceInfoBtnWidget>();
        private int maxCount;
        private DivineSenseConfig divineSenseConfig;

        private void Init()
        {
            isAddStack = true;
        }

        public override CTask GetFocus()
        {
            AppBarPanel.OpenPanel(this);
            CustomInit(callback);
            return base.GetFocus();
        }

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

        protected override void AddEvent()
        {
        }

        protected override void DelEvent()
        {
        }

        public override void AddButtonEvent()
        {
            Btn_Ok.onClick.AddListener(async () =>
            {
                if (EventSystemManager.Instance.GetShenShiCount() >=
                    divineSenseConfig.MaxNum)
                {
                    TipMessagePanel.OpenTipMessagePanel(10335);
                    return;
                }

                // if (useCount == 0)
                // {
                //     // DivineSenceRestoredPanel divineSenceRestoredPanel =  await DivineSenceRestoredPanel.OpenPanel();
                //     // await divineSenceRestoredPanel.UIClosed();
                //     // CustomInit(callback);
                //     return;
                // }

                if (AccountFileInfo.Instance.playerData.divineSensePoint <
                    PlayerManager.Instance.gameConstantConfig.DetectEventCount)
                {
                    DivineSenceRestoredPanel divineSenceRestoredPanel = await DivineSenceRestoredPanel.OpenPanel();
                    await divineSenceRestoredPanel.UIClosed();
                    CustomInit(callback);
                    return;
                }

                useItems.Clear();
                foreach (var senceInfoBtnWidget in _divineSenceInfoBtnWidgets)
                {
                    if (senceInfoBtnWidget.type == 2 && senceInfoBtnWidget.ItemInfo != null)
                    {
                        useItems.Add(senceInfoBtnWidget.ItemInfo);
                    }
                }

                callback?.Invoke(useCount, useItems);
                GObjectPoolInterface.SetActive(false);
                // UIManager.Instance.HideUIUIPanel(this);
            });
            Btn_Close.onClick.AddListener(() => { UIManager.Instance.HideUIUIPanel(this); });
            Slider_Count.onValueChanged.AddListener((c) => { Slider_Count_OnValueChanged(c); });

            Btn_Tip.onClick.AddListener(() => { DivineSenceLevelPreviewPanel.OpenPanel(); });


            Btn_Event.onClick.AddListener(async () =>
            {
                await DivineSenceEventPreviewPanel.OpenPanel();
                GObjectPoolInterface.SetActive(false);
                // UIManager.Instance.HideUIUIPanel(this, isBreadcrumbBarPanel: false);
            });
        }

        private void Slider_Count_OnValueChanged(float value)
        {
            useCount = (int)value;
            Text_Count.text = LanguageManager.Instance.Text(10253, value);
            // Text_shenshishangxian.text = $"({EventSystemManager.Instance.GetShenShiCount()}<color=green>+{value}</color>/{maxCount})";
            Text_shenshishangxian.text = $"({EventSystemManager.Instance.GetShenShiCount()}/{maxCount})";
            foreach (var senceInfoBtnWidget in _divineSenceInfoBtnWidgets)
            {
                senceInfoBtnWidget.UpdateItermCount(useCount);
            }
        }

        public async void CustomInit(Action<int, List<ItemInfo>> callback)
        {
            if (PlayerGuideManager.Instance.GuideIsCanDo(2, 1))
            {
                PlayerGuideManager.Instance.NextGuide();
            }

            // if (PlayerGuideManager.Instance.GuideIsCanDo(3, 1))
            // {
            //     PlayerGuideManager.Instance.NextGuide();
            // }

            _divineSenceInfoBtnWidgets.Clear();
            divineSenseConfig =
                ConfigComponent.Instance.Get<DivineSenseConfig>(AccountFileInfo.Instance.playerData.divineSenseLevel);
            HeroPowerUpConfig heroPowerUpConfig = PlayerManager.Instance.myHero.powerUpConfig;

            Text_Level.text =
                LanguageManager.Instance.Text(10251, AccountFileInfo.Instance.playerData.divineSenseLevel);
            Text_Exp.text = $"{AccountFileInfo.Instance.playerData.divineSenseexp}/{divineSenseConfig.exp}";
            Slider_Exp.maxValue = divineSenseConfig.exp;
            Slider_Exp.value = AccountFileInfo.Instance.playerData.divineSenseexp;

            int count = (int)(AccountFileInfo.Instance.playerData.divineSensePoint /
                              PlayerManager.Instance.gameConstantConfig.DetectEventCount);
            maxCount = heroPowerUpConfig.ShenshiMax / PlayerManager.Instance.gameConstantConfig.DetectEventCount;
            maxCount = maxCount > divineSenseConfig.MaxNum ? divineSenseConfig.MaxNum : maxCount;
            count = count + EventSystemManager.Instance.GetShenShiCount() > maxCount
                ? maxCount - EventSystemManager.Instance.GetShenShiCount()
                : count;


            if (count == 1 || count == 0)
            {
                Slider_Count.minValue = 0;
                Slider_Count.maxValue = count;
                Slider_Count.value = count;
                Slider_Count.interactable = false;
            }
            else
            {
                Slider_Count.minValue = 1;
                Slider_Count.maxValue = count;
                Slider_Count.value = count;
                Slider_Count.interactable = true;
            }

            Slider_Count_OnValueChanged(count);

            List<float> probabilities = UtilTools.CalculateProbabilities(divineSenseConfig.QualityBonusChance.ToList());

            for (var i = 0; i < Text_qs.Count; i++)
            {
                Text_qs[i].text = $"{probabilities[i] * 100:F2}%";
            }

            DivineSenceInfoBtnWidget divineSenceInfoBtnWidget =
                await UIManager.Instance.CreateGComponentForObject<DivineSenceInfoBtnWidget>(
                    DivineSenceInfoBtnWidgetGam0, null);
            divineSenceInfoBtnWidget.CustomInit(-1, 1);
            divineSenceInfoBtnWidget.OnClick = OnClick;
            _divineSenceInfoBtnWidgets.Add(divineSenceInfoBtnWidget);
            divineSenceInfoBtnWidget =
                await UIManager.Instance.CreateGComponentForObject<DivineSenceInfoBtnWidget>(
                    DivineSenceInfoBtnWidgetGam1, null);
            divineSenceInfoBtnWidget.CustomInit(-1, 2);
            divineSenceInfoBtnWidget.OnClick = OnClick;
            _divineSenceInfoBtnWidgets.Add(divineSenceInfoBtnWidget);
            // divineSenceInfoBtnWidget = await UIManager.Instance.CreateGComponentForObject<DivineSenceInfoBtnWidget>(DivineSenceInfoBtnWidgetGam2, null);
            // divineSenceInfoBtnWidget.CustomInit(-1, 2);
            // divineSenceInfoBtnWidget.OnClick = OnClick;
            // _divineSenceInfoBtnWidgets.Add(divineSenceInfoBtnWidget);


            this.callback = callback;
        }

        private async void OnClick(ItemWidgetBasic obj)
        {
            DivineSenceInfoBtnWidget divineSenceInfoBtnWidget = obj as DivineSenceInfoBtnWidget;
            if (divineSenceInfoBtnWidget.type == 1)
            {
                DivineSenceRestoredPanel divineSenceRestoredPanel = await DivineSenceRestoredPanel.OpenPanel();
                await divineSenceRestoredPanel.UIClosed();
                CustomInit(callback);
                return;
            }

            List<int> selectType = new List<int>();
            foreach (var senceInfoBtnWidget in _divineSenceInfoBtnWidgets)
            {
                if (senceInfoBtnWidget != divineSenceInfoBtnWidget && senceInfoBtnWidget.type != 1 &&
                    senceInfoBtnWidget.ItemInfo != null)
                {
                    selectType.Add(senceInfoBtnWidget.ItemInfo.config.associateID);
                }
            }

            DivineSenceItemPanel.OpenPanel(divineSenceInfoBtnWidget.ItemInfo, selectType, (id) =>
                {
                    divineSenceInfoBtnWidget.CustomInit(id, divineSenceInfoBtnWidget.type);
                    UpdateBl();
                },
                () =>
                {
                    divineSenceInfoBtnWidget.CustomInit(-1, divineSenceInfoBtnWidget.type);
                    UpdateBl();
                });
        }


        public void UpdateBl()
        {
            Map<int, int> probabilitiesMap = new Map<int, int>();
            foreach (var senceInfoBtnWidget in _divineSenceInfoBtnWidgets)
            {
                if (senceInfoBtnWidget.type == 2 && senceInfoBtnWidget.ItemInfo != null &&
                    senceInfoBtnWidget.ItemInfo.config.associateID == 6)
                {
                    if (!probabilitiesMap.ContainsKey(senceInfoBtnWidget.ItemInfo.config.associateVlaue[0]))
                    {
                        probabilitiesMap.Add(senceInfoBtnWidget.ItemInfo.config.associateVlaue[0],
                            senceInfoBtnWidget.ItemInfo.config.associateVlaue[1]);
                    }
                    else
                    {
                        probabilitiesMap[senceInfoBtnWidget.ItemInfo.config.associateVlaue[0]] +=
                            senceInfoBtnWidget.ItemInfo.config.associateVlaue[1];
                    }
                }

                senceInfoBtnWidget.UpdateItermCount(useCount);
            }

            var QualityBonusChance = divineSenseConfig.QualityBonusChance.ToList();


            foreach (var keyValuePair in probabilitiesMap)
            {
                QualityBonusChance[keyValuePair.Key - 1] *= keyValuePair.Value + 0.01f;
            }

            List<float> probabilities = UtilTools.CalculateProbabilities(QualityBonusChance);
            for (var i = 0; i < Text_qs.Count; i++)
            {
                Text_qs[i].text = $"{probabilities[i] * 100:F2}%";
            }
        }

        public async static CTask OpenPanel(Action<int, List<ItemInfo>> callback)
        {
            DivineSenceInfoPanel divineSenceInfoPanel =
                await UIManager.Instance.LoadAndOpenPanel<DivineSenceInfoPanel>(null, UILayer.Middle);
            divineSenceInfoPanel.CustomInit(callback);
        }
    }
}