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;
        }

        public HeroUpResultType CanUpgrade(HeroInfo heroInfo)
        {
            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;
            }
            
            if (BagController.Instance.IsEnough(GlobalParam.Item_HeroExp_ID, heroInfo.powerUpConfig.levelUpExp))
            {
                return HeroUpResultType.Success;
            }
            else
            {
                return HeroUpResultType.ExpNotEnough;    
            }
        }

        /// <summary>
        /// 英雄升级逻辑，主要是改数据，不在这里做UI表现
        /// </summary>
        /// <param name="heroInfo"></param>
        public HeroUpResultType UpgradeHeroLogic(HeroInfo heroInfo)
        {
            HeroUpResultType resultType = CanUpgrade(heroInfo);
            if (resultType == HeroUpResultType.Success && 
                BagController.Instance.DuctHeroExp(heroInfo.powerUpConfig.levelUpExp))
            {
                heroInfo.Upgrade();
                
                //如果当前英雄等级等于主力等级，则升级时需要重新计算主力等级
                if (heroInfo.level.Value - 1 == m_MainLevel)
                {
                    CalMainLevel();
                }
                
                SendEvent(HeroUpType.Level, heroInfo, HeroUpResultType.Success);
                return HeroUpResultType.Success;
            }
            return resultType;
        }
        
        /// <summary>
        /// 发送英雄提升的事件
        /// </summary>
        /// <param name="upType">提升类型：升级、升星等.</param>
        private 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
                    .IsLevelUpGetNewSkill(heroInfo.level.Value);
                
                data.isSkillUp = upConfig.ID > 0;
                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;
                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)
        {
            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) && 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 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)
                    {
                        isUnLock = true;
                    }
                }
            }

            return isUnLock;
        }


        /// <summary>
        /// 判断【等级】是否可以解锁新技能
        /// </summary>
        /// <param name="level"></param>
        /// <returns></returns>
        public SkillUpConfig IsLevelUpGetNewSkill(int level)
        {
            SkillUpConfig upConfig = new SkillUpConfig();
            foreach (SkillUpConfig skillUpConfig in PlayerManager.Instance.skillUpConfigs)
            {
                if (skillUpConfig.upType == 1 && level == skillUpConfig.upValue)
                {
                    return upConfig;
                }
            }
            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;
        }
        
    }
}