XiuXianGame/Assets/Scripts/GameLogic/RedDot/RedDotManager.cs

using System.Collections.Generic;
using System.Linq;
using Core.Event.Event;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Hero;
using Mono;
using UnityEngine;
using Utility;

public class RedDotManager : Singleton<RedDotManager>
{
    public Map<int, RedDotGroupData> AllRedDotGroupData = new Map<int, RedDotGroupData>();


    // /// <summary>
    // /// 服务器保存的红点信息；
    // /// </summary>
    // private Map<int, AccountFileInfo.RedDot> RedDots = new Map<int, AccountFileInfo.RedDot>();


    public void AddRedDot(AccountFileInfo.RedDot redDot)
    {
        AccountFileInfo.RedDot redDot1 = GetRedDot(redDot.id);

        if (redDot1 != null)
        {
            redDot1 = redDot;
        }
        else
        {
            AccountFileInfo.Instance.playerData.RedDotDatas.Add(redDot);
        }

        AccountFileInfo.Instance.SavePlayerData();
    }


    public AccountFileInfo.RedDot GetRedDot(int id)
    {
        AccountFileInfo.RedDot redDot = AccountFileInfo.Instance.playerData.RedDotDatas.FirstOrDefault(r => r.id == id);
        if (redDot == null)
        {
            return null;
        }

        return redDot;
    }

    /// <summary>
    /// 所有红点检测注入
    /// </summary>
    public void Init()
    {
        ReddotConfig[] reddotConfigs = ConfigComponent.Instance.GetAll<ReddotConfig>();
        foreach (var reddotConfig in reddotConfigs)
        {
            if (AllRedDotGroupData.TryGetValue(reddotConfig.GroupID, out var value))
            {
                value.AddRedDotData(reddotConfig.ID);
            }
            else
            {
                RedDotGroupData redDotGroupData = new RedDotGroupData();
                redDotGroupData.Init(reddotConfig.ID);
                AllRedDotGroupData.Add(reddotConfig.GroupID, redDotGroupData);
            }
        }
    }


    /// <summary>
    /// 改变红点状态
    /// </summary>
    /// <param name="redDotConfigId">对应红点id</param>
    /// <param name="type">0是关闭 1是开启</param>
    public void ChangeStateRedDot(int redDotConfigId, int type)
    {
        ReddotConfig reddotConfig = ConfigComponent.Instance.Get<ReddotConfig>(redDotConfigId);

        if (reddotConfig.ID == 0)
        {
            LogTool.Log("红点id找不到:" + redDotConfigId);
            return;
        }


        if (AllRedDotGroupData.Count <= 0)
            return;

        if (type == 0)
        {
            AllRedDotGroupData[reddotConfig.GroupID].AllRedDotData[reddotConfig.Layer][redDotConfigId].isEnable = false;
        }
        else
        {
            AllRedDotGroupData[reddotConfig.GroupID].AllRedDotData[reddotConfig.Layer][redDotConfigId].isEnable = true;
        }

        AllRedDotUpDate();
    }


    /// <summary>
    /// 
    /// </summary>
    /// <param name="redDotConfigId"></param>
    /// <param name="type">1打开0关闭</param>
    public void TempChangeStateRedDot(int redDotConfigId, int type)
    {
        ReddotConfig reddotConfig = ConfigComponent.Instance.Get<ReddotConfig>(redDotConfigId);

        EventManager.Instance.Dispatch(CustomEventType.RedDotChangeState, new DefaultEventData()
        {
            eventData = new[]
            {
                redDotConfigId,
                type
            }
        });
    }


    /// <summary>
    /// 所有红点更新
    /// </summary>
    public void AllRedDotUpDate()
    {
        EventManager.Instance.Dispatch(CustomEventType.RedDotUpdate, new DefaultEventData() { eventData = 0 });
    }


    /// <summary>
    /// 指定某个红点组更新
    /// </summary>
    /// <param name="targetGroupId"></param>
    public void TarGetRedDotUpDate(int targetGroupId)
    {
        if (AllRedDotGroupData.ContainsKey(targetGroupId))
        {
            ReddotConfig reddotConfig =
                ConfigComponent.Instance.Get<ReddotConfig>(AllRedDotGroupData[targetGroupId].Id);

            if (reddotConfig.LinkGroupID != null)
            {
                foreach (var i in reddotConfig.LinkGroupID)
                {
                    EventManager.Instance.Dispatch(CustomEventType.RedDotUpdate, new DefaultEventData()
                    {
                        eventData = i
                    });
                }
            }
        }


        EventManager.Instance.Dispatch(CustomEventType.RedDotUpdate, new DefaultEventData()
        {
            eventData = targetGroupId
        });
    }

    public bool TargetRedDotIsEnable(int redDotConfigID)
    {
        if (AllRedDotGroupData.Count <= 0)
        {
            return false;
        }

        ReddotConfig reddotConfig = ConfigComponent.Instance.Get<ReddotConfig>(redDotConfigID);

        if (reddotConfig.ID == 0)
        {
            // LogTool.Log("红点id找不到:" + redDotConfigID);
            return false;
        }


        bool isEnable = false;
        if (reddotConfig.LinkGroupID != null)
        {
            foreach (var groupID in reddotConfig.LinkGroupID) //遍历link的组
            {
                if (AllRedDotGroupData.ContainsKey(groupID))
                {
                    foreach (var keyValuePair in AllRedDotGroupData[groupID].AllRedDotData) //遍历所有layer的红点
                    {
                        foreach (var redDotData in keyValuePair.Value) //遍历某一个layer的红点
                        {
                            ReddotConfig _redDotConfig =
                                ConfigComponent.Instance.Get<ReddotConfig>(redDotData.Value.Id); //具体某一个红点

                            if (TargetRedDotIsEnable(_redDotConfig.ID))
                            {
                                isEnable = true;
                                break;
                            }
                        }
                    }
                }
            }
        }
        else
        {
            AllRedDotGroupData[reddotConfig.GroupID].Update();
            if (AllRedDotGroupData[reddotConfig.GroupID].TargetLayerIsEnable(reddotConfig.Layer))
            {
                isEnable = true;
            }
        }

        return isEnable;
    }


    public bool TargetRedDotIsEnable2(int redDotConfigID)
    {
        bool isEnable = false;
        ReddotConfig reddotConfig = ConfigComponent.Instance.Get<ReddotConfig>(redDotConfigID);
        AllRedDotGroupData[reddotConfig.GroupID].Update();
        if (AllRedDotGroupData[reddotConfig.GroupID].TargetLayerIsEnable(reddotConfig.Layer))
        {
            isEnable = true;
        }

        return isEnable;
    }

    public bool TargetRedDotIsEnableForType01(int redDotGroupID, object value)
    {
        switch (redDotGroupID)
        {
            case 2:
                SkillInfo skillInfo = value as SkillInfo;
                if (isSkillStar(skillInfo))
                {
                    return true;
                }

                if (!PlayerManager.Instance.GongFaControl.allUseSkill.Contains(skillInfo))
                {
                    return false;
                }

                return isSkillUpgrade(value as SkillInfo);
            case 9:
                object[] objects = value as object[];
                return IsFabaoUpgrade1((int)objects[1], objects[0] as FaBaoInfo);

            case 10:
                return IsFabaoUpgrade(value as FaBaoInfo);
                break;
            case 12:
                return isSkillUpgrade(value as SkillInfo);
                break;
            case 13:
                return isSkillStar(value as SkillInfo);
                break;
        }

        return false;
    }

    public bool isSkillUpgrade(SkillInfo _skillInfo)
    {
        if (_skillInfo == null)
            return false;


        var _skillPowerupConfigs = ConfigComponent.Instance.GetAll<SkillPowerupConfig>();
        if (_skillInfo.SkillData.level >= _skillPowerupConfigs.Length)
        {
            return false;
        }

        if (PlayerManager.Instance.myHero.level.Value < _skillInfo.SkillPowerupConfig.PlayerLevelLimit)
        {
            return false;
        }

        for (var i = 0; i < _skillInfo.SkillPowerupConfig.LevelupItem.Length; i++)
        {
            if (!PlayerManager.Instance.BagController.IsEnough(_skillInfo.SkillPowerupConfig.LevelupItem[i],
                    _skillInfo.SkillPowerupConfig.LevelupItemNum[i]))
            {
                return false;
            }
        }

        return true;
    }

    public bool isSkillUpgradeDaYu4(SkillInfo _skillInfo)
    {
        if (_skillInfo == null)
            return false;


        var _skillPowerupConfigs = ConfigComponent.Instance.GetAll<SkillPowerupConfig>();


        for (int i = _skillInfo.SkillPowerupConfig.ID; i < _skillInfo.SkillPowerupConfig.ID + 4; i++)
        {
            SkillPowerupConfig skillPowerupConfig = ConfigComponent.Instance.Get<SkillPowerupConfig>(i);
            if (skillPowerupConfig.ID >= _skillPowerupConfigs.Length)
            {
                return false;
            }

            if (PlayerManager.Instance.myHero.level.Value < skillPowerupConfig.PlayerLevelLimit)
            {
                return false;
            }

            for (var j = 0; j < skillPowerupConfig.LevelupItem.Length; j++)
            {
                if (!PlayerManager.Instance.BagController.IsEnough(skillPowerupConfig.LevelupItem[j],
                        skillPowerupConfig.LevelupItemNum[j]))
                {
                    return false;
                }
            }
        }


        return true;
    }

    public bool isSkillStar(SkillInfo _skillInfo)
    {
        if (_skillInfo == null)
            return false;
        List<SkillConfig> allSkillConfigs = ConfigComponent.Instance.GetAll<SkillConfig>().ToList();
        var configs = allSkillConfigs.Where(s => s.IDGroup == _skillInfo.skillConfig.IDGroup).ToList();

        if (_skillInfo.SkillData.star >= configs.Count)
        {
            return false;
        }

        ItemConfig itemConfig = ConfigComponent.Instance.Get<ItemConfig>(_skillInfo.skillConfig.PieceID);

        SkillConstant skillConstant = ConfigComponent.Instance.Get<SkillConstant>(itemConfig.quality);
        if (skillConstant.SkillPromoteNeedPieceNum == null)
        {
            return false;
        }

        int count = skillConstant.SkillPromoteNeedPieceNum[_skillInfo.skillConfig.level - 1];

        if (!PlayerManager.Instance.BagController.IsEnough(_skillInfo.skillConfig.PieceID, count))
        {
            return false;
        }

        return true;
    }

    public bool IsFabaoUpgrade(FaBaoInfo faBaoInfo)
    {
        if (faBaoInfo == null)
            return false;
        if (faBaoInfo.FabaoPowerupConfig.ID >=
            ConfigComponent.Instance.GetAll<FabaoPowerupConfig>().Length)
        {
            return false;
        }

        if (PlayerManager.Instance.myHero.powerUpConfig.ID < faBaoInfo.FabaoPowerupConfig.NeedLv)
        {
            return false;
        }

        for (var i = 0; i < faBaoInfo.FabaoPowerupConfig.PowerupItemIDs.Length; i++)
        {
            if (!PlayerManager.Instance.BagController.IsEnough(
                    faBaoInfo.FabaoPowerupConfig.PowerupItemIDs[i],
                    faBaoInfo.FabaoPowerupConfig.PowerupItemCosts[i]))
            {
                return false;
            }
        }

        ItemConfig itemConfig =
            ConfigComponent.Instance.Get<ItemConfig>(faBaoInfo.FabaoConfig.ItemID);
        ItemConfig itemConfig2 = ConfigComponent.Instance.Get<ItemConfig>(itemConfig.associateVlaue[0]);
        if (faBaoInfo.FabaoPowerupConfig.PromotePieceNum != null &&
            faBaoInfo.FabaoPowerupConfig.PromotePieceNum[itemConfig2.quality - 1] != -1)
        {
            if (!PlayerManager.Instance.BagController.IsEnough(itemConfig.associateVlaue[0],
                    faBaoInfo.FabaoPowerupConfig.PromotePieceNum[itemConfig2.quality - 1]))
            {
                return false;
            }
        }

        return true;
    }

    public bool IsFabaoUpgrade1(int index, FaBaoInfo faBaoInfo)
    {
        int redDotID = 9;
        bool isEnable = true;
        // object[] objects = value as object[];


        if (index > PlayerManager.Instance.myHero.powerUpConfig.MaxFabaoNum - 1)
        {
            HeroPowerUpConfig[] heroPowerUpConfigs = ConfigComponent.Instance.GetAll<HeroPowerUpConfig>();
            foreach (var heroPowerUpConfig in heroPowerUpConfigs)
            {
                if (heroPowerUpConfig.MaxFabaoNum > PlayerManager.Instance.myHero.powerUpConfig.MaxFabaoNum)
                {
                    isEnable = false;
                }
            }
        }

        if (isEnable)
        {
            AccountFileInfo.RedDot redDot = RedDotManager.Instance.GetRedDot(redDotID);
            if (redDot == null)
            {
                return true;
            }
            else
            {
                if (redDot.Params.Contains(index.ToString()))
                {
                    return IsFabaoUpgrade(faBaoInfo);
                }
                else
                {
                    return true;
                }
            }
        }

        return false;
    }


    public override void Dispose()
    {
        AllRedDotGroupData.Clear();
        base.Dispose();
    }
}