NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/UI/Energy/EnergyManager.cs

/****************************************************
 文件：Assets/Code/Scripts/Gameplay/UI/Energy/EnergyManager.cs
 作者：yuntao-Hu
 时间：2024/5
 描述：管理体力相关信息
 接口：
    public int ItemIDBuyEnergyCount()
    public int GetItemIDBuyEnergy(int index)
    public int GetMaxEnergyPoint()
    public uint GetNowEnergy()
    public DateTime GetNextEnergyRecoverTime()

    public void BuyEnergy(int itemID, uint usageAmount)
    public bool isItemCanBuyEnergy(int itemID)
    public int GetConvertConsumes(int itemID, int usageAmount = 1)
    public int GetConvertRecharges(int itemID, int usageAmount = 1)

 *****************************************************/

using cfg.ActorCfg;
using Framework;
using Gameplay;
using Gameplay.Common;
using Gameplay.Net;
using NLDPB;
using PhxhSDK;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class EnergyManager : Singlenton<EnergyManager>
{
    private List<int> itemIdBuyEnergy = new List<int>(); //= { ENERGY_ITEM_ID, GLConfig.Inst.data.DiamondItemId };//更新体力补充方式时在此处添加物品ID
                                                                                                  //按优先级顺序，将钻石补充方式放在最后

    ConvertRatesWrap convertRatesWrap;

    #region class
    /// <summary>
    /// 存储体力转换率
    /// </summary>
    class ConvertRatesWrap
    {
        private Dictionary<int, ConversionRate> convertRates;

        public ConvertRatesWrap()
        {
            convertRates = new Dictionary<int, ConversionRate>();
            if (EnergyManager.Instance.itemIdBuyEnergy.Count == 0)
                Instance.loadAndInit();

            for (int i = 0; i < EnergyManager.Instance.itemIdBuyEnergy.Count; i++)
            {
                int itemID = EnergyManager.Instance.itemIdBuyEnergy[i];
                AddRate(itemID, RateConfig(itemID));
            }
        }

        List<int> RateConfig(int itemID)
        {

            if (itemID == GLConfig.Inst.data.DiamondItemId)
            {
                return GLConfig.Inst.data.DiamondExchangeEnergy;
            }
            else 
            {
                DataItem itemData = CategoryManager.Instance.GetItemData(itemID);
                if (itemData == null || itemData.Param2 != GLConfig.Inst.data.EnergyPointID)//param2为转化物品ID
                {
                    DebugUtil.LogError("该道具不具备补充体力功能或并非可使用道具，错误物品id： " + itemID
                        + "\n请检查是否错误的将其加入itemIdBuyEnergy数组，或Item配置表中未配置道具转化参数");
                    return default;
                }
                return new List<int> { 1, itemData.Param3 };//兑换比例：1→Param3
            }
        }
        void AddRate(int itemID, int consume, int recharge)
        {
            convertRates.Add(itemID, new ConversionRate(consume, recharge));
        }
        void AddRate(int itemID, List<int> exchangeRate)
        {
            if (exchangeRate == null)
            {
                DebugUtil.LogError("传入转化率list为null\n该物品已加入EnergyManager内itemIDBuyEnergy数组，但未配置转化率，错误物品id： " + itemID);
                return;
            }
            if (exchangeRate.Count >= 2)
                convertRates.Add(itemID, new ConversionRate(exchangeRate[0], exchangeRate[1]));
            else
                DebugUtil.LogError("转化率list传入参数不足！\n错误物品id： " + itemID);
        }

        //API
        public bool isRateContained(int itemID)
        {
            return convertRates.ContainsKey(itemID);
        }
        public int GetConsume(int itemID)
        {
            if (convertRates.ContainsKey(itemID))
            {
                return convertRates[itemID].consume;
            }
            else
            {
                DebugUtil.LogError("不包含的体力补充方式！请检查！");
                return default;
            }
        }
        public int GetRecharge(int itemID)
        {
            if (convertRates.ContainsKey(itemID))
            {
                return convertRates[itemID].recharge;
            }
            else
            {
                DebugUtil.LogError("不包含的体力补充方式！请检查！");
                return default;
            }
        }

        //class
        public class ConversionRate
        {
            public int consume;
            public int recharge;

            public ConversionRate(int consume, int recharge)
            {
                this.consume = consume;
                this.recharge = recharge;
            }
        }
    }
    #endregion

    void loadAndInit()
    {
        itemIdBuyEnergy.Clear();
        List<DataItem> consumeItems = CategoryManager.Instance.GetItemsByType(StorageItemType.ConsumableItem, inStorage: false);
        foreach (var item in consumeItems)
        {
            if (item.Param2 == GLConfig.Inst.data.EnergyPointID)//物品可以转化为体力
            {
                itemIdBuyEnergy.Add(item.ID);
            }
        }
        itemIdBuyEnergy.Add(GLConfig.Inst.data.DiamondItemId);
        //按优先级顺序，将钻石补充方式放在最后
    }

    #region API
    public int ItemIDBuyEnergyCount()
    {
        if (itemIdBuyEnergy.Count == 0)
        {
            loadAndInit();
        }
        return itemIdBuyEnergy.Count;
    }
    /// <summary>
    /// 根据索引获取购买体力物品ID
    /// </summary>
    /// <param name="index">补充体力方式索引</param>
    /// <returns></returns>
    public int GetItemIDBuyEnergy(int index)
    {
        if (index < ItemIDBuyEnergyCount())
            return itemIdBuyEnergy[index];
        else
        {
            DebugUtil.LogError("购买体力物品ID超出范围，请检查！");
            return 0;
        }
    }

    /// <summary>
    /// 获取最大体力
    /// </summary>
    /// <returns></returns>
    public int GetMaxEnergyPoint()
    {
        var level = Actor.Instance.Base.GetProp(ActorProp.Level);  
        var actorCfg = ActorLevelTableHelper.Instance.Get((int)level);
        return actorCfg.MaxEnergy;
    }
    /// <summary>
    /// 获取当前体力
    /// </summary>
    /// <returns></returns>
    public uint GetNowEnergy()
    {
        return CategoryManager.Instance.GetItemCount(GLConfig.Inst.data.EnergyPointID);
    }
    /// <summary>
    /// 获取下一次体力恢复时间
    /// </summary>
    /// <returns></returns>
    public DateTime GetNextEnergyRecoverTime()
    {
        DateTime lastDateTime = CommonUtils.GetTimeByTimestamp(Actor.Instance.Logic.GetCount((uint)LogicID.EnergyRecoverTime));

        return lastDateTime.AddSeconds(TableManager.Instance.Tables.GlobalConfig.EnergyPointRecoverTime);
    }

    /// <summary>
    /// 检查体力是否足够
    /// </summary>
    /// <param name="requireEnergy"></param>
    /// <returns></returns>
    public bool EnergyCheck(int requireEnergy)
    {
        int nowEnergy = (int)GetNowEnergy();
        return nowEnergy >= requireEnergy;
    }

    /// <summary>
    /// 兑换体力
    /// </summary>
    /// <param name="itemID">消耗物品ID</param>
    /// <param name="usageAmount">物品使用份数</param>
    public void BuyEnergy(int itemID, uint usageAmount)
    {
        if (isItemCanBuyEnergy(itemID))
        {
            if (itemID == GLConfig.Inst.data.DiamondItemId)
            {
                NetHelper.ConvertResources((uint)itemID, usageAmount, (uint)GLConfig.Inst.data.EnergyPointID);
            }
            else
            {
                CategoryManager.Instance.UseItem(itemID, (int)usageAmount, GLConfig.Inst.data.EnergyPointID);
            }//如果不是货币兑换方式，直接使用道具补充逻辑
        }
    }
    /// <summary>
    /// 该物品是否有补充体力功能
    /// </summary>
    /// <param name="itemID"></param>
    /// <returns></returns>
    public bool isItemCanBuyEnergy(int itemID)
    {
        convertRatesWrap ??= new ConvertRatesWrap();
        return convertRatesWrap.isRateContained(itemID);
    }
    /// <summary>
    /// 每份物品补充体力时的物品实际消耗量，参数可设定份数
    /// </summary>
    /// <param name="itemID"></param>
    /// <param name="usageAmount">物品份数</param>
    /// <returns></returns>
    public int GetConvertConsumes(int itemID, int usageAmount = 1)
    {
        if (isItemCanBuyEnergy(itemID))
            return usageAmount * convertRatesWrap.GetConsume(itemID);
        else
        {
            DebugUtil.LogError("补充体力列表内不包含该物品，不可补充体力!请检查\n错误物品ID: " + itemID);
            return 0;
        }

    }
    /// <summary>
    /// 每份物品补充体力时的体力补充量，参数可设定份数
    /// </summary>
    /// <param name="itemID"></param>
    /// <param name="usageAmount">物品份数</param>
    /// <returns></returns>
    public int GetConvertRecharges(int itemID, int usageAmount = 1)
    {
        if (isItemCanBuyEnergy(itemID))
            return usageAmount * convertRatesWrap.GetRecharge(itemID);
        else
        {
            DebugUtil.LogError("补充体力列表内不包含该物品，不可补充体力!请检查\n错误物品ID: " + itemID);
            return 0;
        }
    }

    /// <summary>
    /// 获取当前选中状态下的最大消耗数目(实际数据需要乘比例转化)
    /// </summary>
    /// <param name="itemID"></param>
    /// <param name="itemLimited"></param>
    /// <returns></returns>
    public int MaxConsumeAmountWithoutConvert(int itemID, out bool itemLimited)
    {
        int maxConsumeRate = 0;
        int maxConsumeRateByEnergy = 0;

        if (!ValueValidator.IsIdValid(itemID))
        {
            DebugUtil.LogError("补充体力方式对应的物品ID不合规，请检查配置！\n错误物品ID: " + itemID);
        }
        int consumePerItem = GetConvertConsumes(itemID);
        int rechargePerItem = GetConvertRecharges(itemID);
        //道具数目限制
        uint AmountInStorage = CategoryManager.Instance.GetItemCount(itemID);
        if (consumePerItem != 0)
            maxConsumeRate = (int)(AmountInStorage / consumePerItem);

        //体力上限限制
        uint energyToMax = (uint)CategoryManager.Instance.GetItemMaxCount(GLConfig.Inst.data.EnergyPointID) - CategoryManager.Instance.GetItemCount(GLConfig.Inst.data.EnergyPointID);
        if (rechargePerItem != 0)
            maxConsumeRateByEnergy = (int)(energyToMax / rechargePerItem);

        itemLimited = maxConsumeRate <= maxConsumeRateByEnergy;

        return Math.Min(maxConsumeRate, maxConsumeRateByEnergy);
    }

    public async void OpenBuyEnergyWindow()
    {
        await UI_BuyEnergyController.Open();
    }
    #endregion
}