XiuXianGame/Assets/Scripts/GameLogic/Combat/Hero/CombatHeroSkillControl.cs

using System;
using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Skill;
using UnityEngine;

namespace GameLogic.Combat.Hero
{
    public class CombatHeroSkillControl : IDisposable
    {
        private BetterList<SkillBasic> allSkill = new BetterList<SkillBasic>();

        /// <summary>
        /// 技能指令，0表示没有技能；
        /// </summary>
        private BetterList<SkillBasic> SkillCommands = new BetterList<SkillBasic>();

        /// <summary>
        /// 当前能使用的技能
        /// </summary>
        public SkillBasic currUseSkill;

        private CombatHeroEntity _combatHeroEntity;

        /// <summary>
        /// 普攻
        /// </summary>
        public SkillBasic NormalAttack;

        public float NormalAttCd;

        public float NormalAttSpeedScale;

        public void Init(CombatHeroEntity combatHeroEntity)
        {
            _combatHeroEntity = combatHeroEntity;
            List<int> skillId = _combatHeroEntity.CurrCombatHeroInfo.unLockSkills;
            if (skillId != null)
            {
                for (int i = 0; i < skillId.Count; i++)
                {
                    SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(skillId[i]);
                    AddSkill(skillConfig);
                }
            }

            // foreach (SkillConfig skillConfig in combatHeroEntity.CurrCombatHeroInfo.skillConfigs)
            // {
            //     AddSkill(skillConfig);
            // }
        }


        public void UpdateSkill(List<int> skillIDs)
        {
            for (int i = 0; i < skillIDs.Count; i++)
            {
                SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(skillIDs[i]);
                // SkillConfig skillConfig = skillIDs[i];
                SkillBasic skillBasic = GetSkillBasic(skillConfig.IDGroup);
                if (skillBasic == null)
                {
                    AddSkill(skillConfig);
                }
                else
                {
                    if (skillBasic.SelfSkillConfig.ID != skillConfig.ID)
                    {
                        skillBasic.InitSkillConfig(skillConfig);
                    }
                }
            }
        }

        private SkillBasic GetSkillBasic(int skillGroupId)
        {
            for (int i = 0; i < SkillCommands.Count; i++)
            {
                if (SkillCommands[i].SelfSkillConfig.IDGroup == skillGroupId)
                {
                    return SkillCommands[i];
                }
            }

            return null;
        }

        public void AddSkill(SkillConfig skillConfig)
        {
            SkillBasic skillBasic = SkillScriptManager.Instance.CreateSkillBasic(skillConfig);
            allSkill.Add(skillBasic);
            skillBasic.InitSkill(_combatHeroEntity);
            if (skillConfig.SkillType == 1)
            {
                NormalAttack = skillBasic;
                NormalAttack.ActiveTimeLineGroupName = "attack";
                SetNormalAttCd();
            }
        }

        public void AddCommandSkill(SkillBasic skill)
        {
            SkillCommands.Add(skill);
        }

        public void RemoveCommandSkill(SkillBasic skill)
        {
            SkillCommands.Remove(skill);
        }

        public void ClearCommandSkill()
        {
            SkillCommands.Clear();
        }

        public void UseSkill(SkillBasic skill)
        {
            CombatUseSkillEventData combatUseSkillEventData = CombatUseSkillEventData.Create();
            combatUseSkillEventData.useSkill = skill;
            CombatEventManager.Instance.Dispatch(CombatEventType.UseSkill, combatUseSkillEventData);
            currUseSkill = skill;
            skill.UseSkill();
            if (skill.SelfSkillConfig.SkillType == 1)
            {
                SetNormalAttCd();
            }
        }

        /// <summary>
        /// 判断是否有技能可释放
        /// </summary>
        /// <returns></returns>
        public SkillBasic CanReleaseSkill()
        {
            // if (_combatHeroEntity.IsControl())
            // {
            //     return null;
            // }
            if (!_combatHeroEntity.IsEnemy && _combatHeroEntity.CombatAIBasic.currFocusTarget is BannerHero)
            {
                return null;
            }

            SkillBasic skillBasic = null;
            for (int i = 0; i < SkillCommands.size; i++)
            {
                skillBasic = SkillCommands[i];
                break;
            }

            return skillBasic;
        }


        public void Update(float t)
        {
            for (int i = 0; i < allSkill.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                skillBasic.CombatUpdate(t);
                if (skillBasic.SelfSkillConfig.SkillType != 1 && !SkillCommands.Contains(skillBasic) &&
                    currUseSkill != skillBasic)
                {
                    skillBasic.ReduceCd(t);
                    if (skillBasic.SkillCd <= 0 && skillBasic.IsCanUse())
                    {
                        skillBasic.SkillCd = skillBasic.SkillMaxCd;
                        AddCommandSkill(skillBasic);
                    }
                }
            }

            NormalAttCd -= t;
            if (NormalAttCd <= 0 && !SkillCommands.Contains(NormalAttack))
            {
                AddCommandSkill(NormalAttack);
            }
        }

        public void SetNormalAttCd()
        {
            if (NormalAttack == null)
            {
                return;
            }

            string timeLineName = "attack";
            float maxTime = _combatHeroEntity.combatHeroTimeLineControl.TimeLineData.GetTimeLineEventLogicGroupForTime(
                timeLineName, null);
            float attackSpeed = _combatHeroEntity.CurrCombatHeroInfo.attSpeed.Value;
            float cd = 1.0f / attackSpeed;
            float attSpeed = (float)1;
            if (cd < maxTime)
            {
                attSpeed = maxTime / cd;
            }

            NormalAttSpeedScale = attSpeed;
            // Debug.Log(NormalAttSpeedScale);
            NormalAttCd = cd;
        }

        public void Dispose()
        {
            for (int i = 0; i < allSkill.size; i++)
            {
                SkillBasic skillBasic = allSkill[i];
                CObjectPool.Instance.Recycle(skillBasic);
            }

            allSkill.Clear();
            SkillCommands.Clear();
            _combatHeroEntity = null;
            NormalAttack = null;
            currUseSkill = null;
        }
    }
}