XiuXianGame/Assets/Scripts/GameLogic/Hero/HeroController.cs

using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Core.Utility;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Bag;

namespace GameLogic.Hero
{
    public class HeroController
    {
        /// <summary>
        /// 所有英雄
        /// </summary>
        public Dictionary<int, HeroInfo> allHeroDic = new Dictionary<int, HeroInfo>();
        

        /// <summary>
        /// 也可以叫主力(afk的共鸣英雄)，替补英雄等级=主力英雄的最低等级（和afk一样的）
        /// 主力英雄不一定等于上阵英雄，主力英雄只是决定了共鸣等级
        /// </summary>
        public Dictionary<int, HeroInfo> heroDicInLead = new Dictionary<int, HeroInfo>(4);

        /// <summary>
        /// 后备英雄(共享等级)
        /// </summary>
        public Dictionary<int, HeroInfo> heroDicInBack = new Dictionary<int, HeroInfo>();

        public int mainLevel => m_MainLevel;
    

        private int m_MainLevel;


        private void CalMainLevel()
        {
            //主力英雄不足4个时，就没有主力等级的说法
            if (heroDicInLead.Count < GlobalParam.Max_Deploy_HERO)
            {
                m_MainLevel = -1;
                return;
            }

            //计算主力英雄的最低等级
            int tmpLv = 9999;
            foreach (var keyValuePair in heroDicInLead)
            {
                if (keyValuePair.Value.level.Value < tmpLv)
                {
                    tmpLv = keyValuePair.Value.level.Value;
                }
            }
            
            m_MainLevel = tmpLv;
            
            EventManager.Instance.Dispatch(CustomEventType.MainLvUp, new SimpleEventData(){intData = m_MainLevel});
        }

        public HeroUpResultType CanUpgrade(HeroInfo heroInfo, bool isOpenPre = false)
        {
            if (PlayerManager.Instance.gameConstantConfig.maxLv <= heroInfo.level.Value)
            {
                LogTool.Log("已到达最高等级:" + PlayerManager.Instance.gameConstantConfig.maxLv);
                return HeroUpResultType.MaxLv;
            }
            
            //计算主力英雄等级差, 如果再升一级，就大于最大等级差了，就不允许升了.
            if (heroInfo.level.Value - m_MainLevel >= GlobalParam.Max_Main_Level_Difference)
            {
                LogTool.Log(heroInfo.modelID + "主力英雄等级差不能超过:" + GlobalParam.Max_Main_Level_Difference);
                return HeroUpResultType.MainLevelNotEnough;
            }

            //每10级，要打开预览界面后，再升级(如果已经打开，就不判断了)
            if (!isOpenPre && (heroInfo.level.Value + 1) % 10 == 1)
            {
                return HeroUpResultType.NeedOpenPreUI;
            }
            
            if (BagController.Instance.IsEnough(GlobalParam.Item_HeroExp_ID, heroInfo.powerUpConfig.levelUpExp))
            {
                if (isOpenPre)
                {
                    return HeroUpResultType.PlayUpgradeEftFirst;
                }
                return HeroUpResultType.Success;
            }
            else
            {
                return HeroUpResultType.ExpNotEnough;    
            }
        }

        private void DoUpgrade(HeroInfo heroInfo)
        {
            heroInfo.Upgrade();
            PlayerManager.Instance.SaveHeroData(heroInfo);
            //如果当前英雄等级等于主力等级，则升级时需要重新计算主力等级
            if (heroInfo.level.Value - 1 == m_MainLevel)
            {
                CalMainLevel();
            }
            SendEvent(HeroUpType.Level, heroInfo, HeroUpResultType.Success);
        }

        /// <summary>
        /// 英雄升级逻辑，主要是改数据，不在这里做UI表现
        /// </summary>
        /// <param name="heroInfo"></param>
        public HeroUpResultType UpgradeHeroLogic(HeroInfo heroInfo, bool isOpenPre = false)
        {
            HeroUpResultType resultType = CanUpgrade(heroInfo, isOpenPre);
            if (resultType == HeroUpResultType.Success || resultType == HeroUpResultType.PlayUpgradeEftFirst)
            {
                //扣除经验
                bool isOk = BagController.Instance.DuctHeroExp(heroInfo.powerUpConfig.levelUpExp);

                if (isOk)
                {
                    if (resultType == HeroUpResultType.Success)
                    {
                        DoUpgrade(heroInfo);
                    }
                    else if (resultType == HeroUpResultType.PlayUpgradeEftFirst)
                    {
                        //执行逻辑，返回播放特效的类型
                        DoUpgrade(heroInfo);
                        return resultType;
                    }

                    return HeroUpResultType.Success;
                }
            }
            return resultType;
        }
        
        /// <summary>
        /// 发送英雄提升的事件
        /// </summary>
        /// <param name="upType">提升类型：升级、升星等.</param>
        public void SendEvent(HeroUpType upType, HeroInfo heroInfo, HeroUpResultType resultType = HeroUpResultType.None)
        {
            HeroPowerUpEventData data = new HeroPowerUpEventData();
            data.heroModelID = heroInfo.modelID;
            data.upType = upType;
            data.ResultType = resultType;
            
            PlayerManager.Instance.lastHeroInfo = heroInfo;
            EventManager.Instance.Dispatch(CustomEventType.HeroPowerUp, data);
            if (upType == HeroUpType.Level)
            {
                SkillUpConfig upConfig = PlayerManager.Instance.heroController
                    .GetSkillUpConfig4Lv(heroInfo.level.Value);
                
                
                if (upConfig.ID > 0)
                {
                    heroInfo.SkillData.UpdateSkills();
                    data.isSkillUp = true;
                }
                
                EventManager.Instance.Dispatch(CustomEventType.HeroLvUp, data);
            }
            else if (upType == HeroUpType.Promote)
            {
                // SkillUpConfig upConfig = PlayerManager.Instance.heroController
                //     .IsStarUpGetNewSkill(heroInfo.star.Value);
                
                // data.isSkillUp = upConfig.ID > 0;
                
                SkillUpConfig upConfig = PlayerManager.Instance.heroController.GetSkillUpConfig4Star(heroInfo.star.Value);
                
                if (upConfig.ID > 0)
                {
                    heroInfo.SkillData.UpdateSkills();
                    data.isSkillUp = true;
                }
                
                EventManager.Instance.Dispatch(CustomEventType.HeroPromote, data);
            }
        }
        
        public void InitHeroes()
        {
            for (int i = 0; i < AccountFileInfo.Instance.playerData.HeroListData.Count; i++)
            {
                AccountFileInfo.HeroData heroData = AccountFileInfo.Instance.playerData.HeroListData[i];
                HeroInfo heroInfo = new HeroInfo();
                heroInfo.InitHero(heroData);
            
                AddHero(heroInfo);
            }
            
            CalMainLevel();
        }
        
        /// <summary>
        /// 获取英雄
        /// </summary>
        /// <param name="modelID">英雄ID modelID</param>
        /// <returns></returns>
        public CombatHeroInfo GetHeroInfo(int modelID)
        {

            if (allHeroDic.ContainsKey(modelID))
            {
                return allHeroDic[modelID];
            }
            
            LogTool.Error("没有这个英雄" + modelID);
            return null;
        }
        
        
        /// <summary>
        /// 添加英雄
        /// </summary>
        /// <param name="heroInfo"></param>
        public void AddHero(HeroInfo heroInfo)
        {
            if (heroInfo.isLead)
            {
                DeployHeroToLead(heroInfo);
            }
            else
            {
                DeployHeroToBack(heroInfo);
            }
        }

        /// <summary>
        /// 进入主力队伍
        /// </summary>
        /// <param name="heroInfo"></param>
        public void DeployHeroToLead(HeroInfo heroInfo)
        {
            if (heroDicInLead.Count >= GlobalParam.Max_Deploy_HERO)
            {
                return;
            }

            if (heroDicInLead.ContainsKey(heroInfo.modelID))
            {
                LogTool.Error("heroDicInLead不应该出现相同的英雄ID=" + heroInfo.modelID);
                return;
            }
            
            heroDicInLead.Add(heroInfo.modelID, heroInfo);
            heroInfo.isLead = true;
            
            allHeroDic.Add(heroInfo.modelID, heroInfo);
        }

        /// <summary>
        /// 更换主力
        /// </summary>
        /// <param name="heroInfo"></param>
        public void ChangeLeadHero(HeroInfo backHero, HeroInfo leadHero)
        {
            if (!heroDicInLead.ContainsKey(leadHero.modelID))
            {
                LogTool.Error("不是主力" + leadHero.modelID);
                return;
            }
            
            if (!heroDicInBack.ContainsKey(backHero.modelID))
            {
                LogTool.Error("不是替补" + backHero.modelID);
                return;
            }
            
            //从主力中移除，并加入后补
            heroDicInLead.Remove(leadHero.modelID);
            DeployHeroToBack(leadHero);

            //从后补中移除，并加入主力
            heroDicInBack.Remove(backHero.modelID);
            DeployHeroToLead(backHero);
            
            
        }
        
        /// <summary>
        /// 进入后备队伍（英雄背包）
        /// </summary>
        /// <param name="heroInfo"></param>
        public void DeployHeroToBack(HeroInfo heroInfo)
        {
            if (heroDicInBack.ContainsKey(heroInfo.modelID))
            {
                LogTool.Error("heroDicInBack不应该出现相同的英雄ID=" + heroInfo.modelID);
                return;
            }
            
            heroDicInBack.Add(heroInfo.modelID, heroInfo);
            heroInfo.isLead = false;
            
            allHeroDic.Add(heroInfo.modelID, heroInfo);
        }
        
        
         /// <summary>
        /// onlyUnLock=true， 获取已解锁的最高等级的技能
        /// onlyUnLock=false，获取已解锁的最高等级的技能，若都没有解锁，则获取未解锁的1级技能
        /// </summary>
        /// <param name="groupID">技能组</param>
        /// <param name="level">英雄等级</param>
        /// <param name="star">英雄星级</param>
        /// <param name="onlyUnLock">ture=只返回解锁的</param>
        /// <returns></returns>
        public SkillConfig GetHighestLevelOr1(int groupID, int level, int star, bool onlyUnLock = false,bool isMonster=false)
        {
            SkillConfig skillConfig = new SkillConfig();
            
            int lv = 0;
            for(int i = 0; i <  PlayerManager.Instance.groupSkillDic[groupID].Count; i++)
            {
                SkillConfig config = PlayerManager.Instance.groupSkillDic[groupID][i];

                if (i == 0 && !onlyUnLock)
                {
                    skillConfig = config;
                }
                
                // if (config.isUnLock && config.skillConfig.level > lv)
                if(IsUnLockSkill(level, star, config.ID,isMonster) && config.level > lv)
                {
                    lv = config.level;
                    skillConfig = config;
                }
            }
            return skillConfig;
        }
        
        /// <summary>
        /// 技能是否解锁
        /// </summary>
        /// <param name="level">英雄等级</param>
        /// <param name="star">英雄星级</param>
        /// <param name="skillID">技能id</param>
        /// <returns></returns>
        public bool IsUnLockSkill(int level, int star, int skillID,bool isMonster=false)
        {
            bool isUnLock = false;
            if (skillID == GlobalParam.Normal_Attack_Skill_Group_ID)
            {
                isUnLock = true;
            }
            else
            {
                //整体可能有点绕，后面再看优化不
                
                //取技能ID的后两位，后两位是技能解锁表SkillUpConfig的ID, 取这个ID来判断，这个技能技能的解锁情况
                int skillUpID = skillID % 100;
                SkillUpConfig upConfig = ConfigComponent.Instance.Get<SkillUpConfig>(skillUpID);

                //取个位
                int gw = skillUpID % 10;
                
                int skillUpIDLevel1 = -1;
                //当个位>1时(表示技能等级>1)，需要额外判断一下，技能的1级是否已经解锁（可能1级是星级解锁）
                //避免出现，技能是5星解锁解锁1级，200级解锁2级，但玩家现在4星，201级，就不该解锁2级，因为星级不够
                if (gw > 1)
                {
                    //技能1级的解锁ID，例如： 33 - 3 + 1 = 31, 31就是技能1级的解锁条件id
                    skillUpIDLevel1 = skillUpID - gw + 1;
                }
                
                //等级解锁
                if (upConfig.upType == 1)
                {
                    SkillUpConfig skillUpConfigLevel1 = new SkillUpConfig();
                    //准备判断，该技能1级时，是否为星级解锁
                    if (skillUpIDLevel1 > 0)
                    {
                        skillUpConfigLevel1 = ConfigComponent.Instance.Get<SkillUpConfig>(skillUpIDLevel1);
                    }

                    //如果技能的第一级需要星级解锁，需额外判断一下星级是否达到
                    bool isStarEnough = skillUpConfigLevel1.upType != 2 || star > skillUpConfigLevel1.upValue;
                    

                    if (level >= upConfig.upValue && isStarEnough)
                    {
                        isUnLock = true;
                    }
                }
                //星级解锁
                else if (upConfig.upType == 2)
                {
                    if (star >= upConfig.upValue||isMonster)
                    {
                        isUnLock = true;
                    }
                }
            }

            return isUnLock;
        }


        public SkillUpConfig GetSkillUpConfig(int skillID)
        {
            //取技能ID的后两位，后两位是技能解锁表SkillUpConfig的ID, 取这个ID来判断，这个技能技能的解锁情况
            int skillUpID = skillID % 100;
            SkillUpConfig upConfig = ConfigComponent.Instance.Get<SkillUpConfig>(skillUpID);
            return upConfig;
        }

        /// <summary>
        /// 根据【等级】查找是否有技能
        /// </summary>
        /// <param name="level">英雄等级</param>
        /// <returns></returns>
        public SkillUpConfig GetSkillUpConfig4Lv(int level)
        {
            SkillUpConfig upConfig = new SkillUpConfig();
            foreach (SkillUpConfig skillUpConfig in PlayerManager.Instance.skillUpConfigs)
            {
                if (skillUpConfig.upType == 1 && level == skillUpConfig.upValue)
                {
                    return skillUpConfig;
                }
            }
            return upConfig;
        }
        
        
        /// <summary>
        /// 根据【星级】查找是否有技能
        /// </summary>
        /// <param name="level">英雄等级</param>
        /// <returns></returns>
        public SkillUpConfig GetSkillUpConfig4Star(int star)
        {
            SkillUpConfig upConfig = new SkillUpConfig();
            foreach (SkillUpConfig skillUpConfig in PlayerManager.Instance.skillUpConfigs)
            {
                if (skillUpConfig.upType == 2 && star == skillUpConfig.upValue)
                {
                    return skillUpConfig;
                }
            }
            return upConfig;
        }
        
        // /// <summary>
        // /// 判断【星级】是否可以解锁新技能
        // /// </summary>
        // /// <param name="star"></param>
        // /// <returns></returns>
        // public SkillUpConfig IsStarUpGetNewSkill(int star)
        // {
        //     SkillUpConfig upConfig = new SkillUpConfig();
        //     foreach (SkillUpConfig skillUpConfig in PlayerManager.Instance.skillUpConfigs)
        //     {
        //         if (skillUpConfig.upType == 2 && star == skillUpConfig.upValue)
        //         {
        //             return upConfig;
        //         }
        //     }
        //     return upConfig;
        // }
        
    }
}