XiuXianGame/Assets/Scripts/GameLogic/Combat/Skill/DS60102.cs

using Common.Utility.CombatEvent;
using Fort23.Core;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using GameLogic.Player;
using Utility;

namespace GameLogic.Combat.Skill
{
    /// <summary>
    /// 生衍道 ：功法拥有生息之能，每次使用功法能获得对应属性的充能，充能满后获得对应属性的加成 金：提升攻击力 木：恢复生命 水：治疗一个较重伤势 火：功法强度提升 土：玩家防御提升。（全能型）
    /// </summary>
    public class DS60102 : SkillBasic
    {
        public Map<WuXingType, float> currEnergy = new Map<WuXingType, float>();


        private long addAtt;
        private float addAtt_bl;

        private long addDef;
        private float addDef_bl;

        private long addQiangDu;
        private float addQiangDu_bl;

        protected override void ProUseSkill()
        {
        }

        protected override void ProInitSkill()
        {
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, UseSkill);
        }

        private void UseSkill(IEventData iEventData)
        {
            CombatUseSkillEventData combatUseSkillEventData = iEventData as CombatUseSkillEventData;
            SkillBasic skillBasic = combatUseSkillEventData.useSkill;
            if (skillBasic.CombatHeroEntity == CombatHeroEntity && skillBasic.SelfSkillConfig.SkillType == 1)
            {
                float v = SelfSkillConfig.effectValue[0];
                if (currEnergy.ContainsKey(skillBasic.wuXingType))
                {
                    currEnergy[skillBasic.wuXingType] += v;
                    v = currEnergy[skillBasic.wuXingType];
                }
                else
                {
                    currEnergy.Add(skillBasic.wuXingType, v);
                }


                switch (skillBasic.wuXingType)
                {
                    case WuXingType.Gold:
                        GoldLogic();
                        break;
                    case WuXingType.Wood:
                        WoodLogic();
                        break;
                    case WuXingType.Water:
                        WaterLogic();
                        break;
                    case WuXingType.Fire:
                        FireLogic();
                        break;
                    case WuXingType.Earth:
                        EarthLogic();
                        break;
                }
            }
        }


        protected void GoldLogic()
        {
            float max = SelfSkillConfig.effectValue[1];
            float v = currEnergy[WuXingType.Gold];
            if (v >= max)
            {
                currEnergy[WuXingType.Gold] = 0;
                long maxAttack = CombatHeroEntity.MaxCombatHeroInfo.attack.Value;
                float addV = SelfSkillConfig.effectValue[2];

                float maxValue = SelfSkillConfig.effectValue[3];
                if (addV + addAtt_bl > maxValue)
                {
                    addV = maxValue - addAtt_bl;
                }

                addAtt_bl += addV;
                CombatHeroEntity.CurrCombatHeroInfo.attack -= addAtt;
                addAtt = CombatCalculateTool.Instance.GetVlaueRatioForLong(maxAttack, addV);
                CombatHeroEntity.CurrCombatHeroInfo.attack += addAtt;
            }
        }

        protected void WoodLogic()
        {
            float max = SelfSkillConfig.effectValue[4];
            float v = currEnergy[WuXingType.Wood];
            if (v >= max)
            {
                currEnergy[WuXingType.Wood] = 0;
                long h = CombatCalculateTool.Instance.GetVlaueRatioForLong(CombatHeroEntity.MaxCombatHeroInfo.hp.Value,
                    SelfSkillConfig.effectValue[5]);
                CombatCalculateTool.Instance.Recover(CombatHeroEntity,
                    CombatHeroEntity.GetMainHotPoin<CombatHeroHitPoint>(), h, AttType.Skill, HarmType.Default,
                    triggerData);
            }
        }

        protected void WaterLogic()
        {
            float max = SelfSkillConfig.effectValue[6];
            float v = currEnergy[WuXingType.Water];
            if (v < max)
            {
                return;
            }

            currEnergy[WuXingType.Water] = 0;
            float metal_Injury = CombatHeroEntity.CurrCombatHeroInfo.Metal_Injury;
            float Wood_Injury = CombatHeroEntity.CurrCombatHeroInfo.Wood_Injury;
            float Water_Injury = CombatHeroEntity.CurrCombatHeroInfo.Water_Injury;
            float Fire_Injury = CombatHeroEntity.CurrCombatHeroInfo.Fire_Injury;
            float Earth_Injury = CombatHeroEntity.CurrCombatHeroInfo.Earth_Injury;

            float[] injury = { metal_Injury, Wood_Injury, Water_Injury, Fire_Injury, Earth_Injury };
            int minIndex = 0;
            float minValue = injury[0];

            for (int i = 1; i < injury.Length; i++)
            {
                if (injury[i] < minValue)
                {
                    minValue = injury[i];
                    minIndex = i;
                }
            }

            float vInjury = SelfSkillConfig.effectValue[7];
            switch (minIndex)
            {
                case 0:
                    CombatHeroEntity.CurrCombatHeroInfo.Metal_Injury -= vInjury;
                    break;
                case 1:
                    CombatHeroEntity.CurrCombatHeroInfo.Wood_Injury -= vInjury;
                    break;
                case 2:
                    CombatHeroEntity.CurrCombatHeroInfo.Water_Injury -= vInjury;
                    break;
                case 3:
                    CombatHeroEntity.CurrCombatHeroInfo.Fire_Injury -= vInjury;
                    break;
                case 4:
                    CombatHeroEntity.CurrCombatHeroInfo.Earth_Injury -= vInjury;
                    break;
            }
        }

        protected void FireLogic()
        {
            float max = SelfSkillConfig.effectValue[8];
            float v = currEnergy[WuXingType.Fire];
            if (v < max)
            {
                return;
            }

            currEnergy[WuXingType.Fire] = 0;
            // float currGongFaStrength = CombatHeroEntity.CurrCombatHeroInfo.gongFaStrength;
            float addV = SelfSkillConfig.effectValue[9];

            float maxValue = SelfSkillConfig.effectValue[10];
            if (addV + addQiangDu_bl > maxValue)
            {
                addV = maxValue - addQiangDu_bl;
            }

            CombatHeroEntity.CurrCombatHeroInfo.gongFaStrength -= addQiangDu_bl;
            addQiangDu_bl += addV;
            CombatHeroEntity.CurrCombatHeroInfo.gongFaStrength += addQiangDu_bl;
        }

        protected void EarthLogic()
        {
            float max = SelfSkillConfig.effectValue[11];
            float v = currEnergy[WuXingType.Earth];
            if (v < max)
            {
                return;
            }

            currEnergy[WuXingType.Earth] = 0;
            long maxDef = CombatHeroEntity.MaxCombatHeroInfo.defense.Value;
            float addV = SelfSkillConfig.effectValue[12];

            float maxValue = SelfSkillConfig.effectValue[13];
            if (addV + addDef_bl > maxValue)
            {
                addV = maxValue - addDef_bl;
            }

            addDef_bl += addV;
            CombatHeroEntity.CurrCombatHeroInfo.defense -= addDef;
            addDef = CombatCalculateTool.Instance.GetVlaueRatioForLong(maxDef, addV);
            CombatHeroEntity.CurrCombatHeroInfo.attack += addDef;
        }

        private void Finish()
        {
            // if (_updateTime)
            // {
            //     CombatHeroEntity.CurrCombatHeroInfo.addAttSpeed_bl -= SelfSkillConfig.effectValue[2];
            //     _updateTime = false;
            // }
        }


        protected override void ProCombatUpdate(float time)
        {
            // if (_updateTime)
            // {
            //     _currTime += time;
            //     if (_currTime >= SelfSkillConfig.effectValue[3])
            //     {
            //         Finish();
            //     }
            // }
        }

        protected override void ProDispose()
        {
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, UseSkill);
        }
    }
}