Exemple #1
0
        public static SkillObj Summon(int id, SkillObj srcObj, SkillObj tarObj, SkillInfo_New skillInfo, SkillConfig_New skillConfig)
        {
            SkillObj summonObj = null;

            if (srcObj != null)
            {
                summonObj = srcObj.Summon(id, tarObj, skillInfo, skillConfig);
                var srcBuffList = srcObj.GetBuffList();
                //Source buff fix
                if (srcBuffList != null)
                {
                    foreach (var buffInfo in srcBuffList)
                    {
                        BuffLogic buffLogic = GetBuffLogic(buffInfo, srcObj);
                        int       buffId    = srcObj.GetBuffID(buffInfo);
                        if (buffLogic != null)
                        {
                            BuffConfig_New buffConfig = srcObj.GetBuffConfig(buffId);
                            buffLogic.OnSummon(id, srcObj, summonObj, buffInfo, buffConfig);
                        }
                        else
                        {
                            srcObj.LogInfo("something error in BattleModule.Summon src buff:[{0}]".F(buffId));
                        }
                    }
                }
            }
            return(summonObj);
        }
Exemple #2
0
        /// <summary>
        /// 单人技能的tick,这个需要手动调用
        /// </summary>
        /// <param name="self"></param>
        public static void Tick_Battle(SkillObj self)
        {
            if (self.IsDead())
            {
                return;
            }
            var skillList = self.GetSkillList(true);
            var buffList  = self.GetBuffList(true);
            var CDKeyList = self.GetCDKeyList();

            //buff
            if (buffList != null)
            {
                foreach (var buffInfo in buffList)
                {
                    BuffLogic buffLogic = GetBuffLogic(buffInfo, self);
                    if (buffLogic != null)
                    {
                        int            buffId     = self.GetBuffID(buffInfo);
                        BuffConfig_New buffConfig = self.GetBuffConfig(buffId);
                        buffLogic.Tick(self, buffInfo, buffConfig);
                    }
                    else
                    {
                        self.LogInfo("something error {0}".F(self.GetBuffID(buffInfo)));
                    }
                }
            }
            //技能
            if (skillList != null)
            {
                foreach (var skillInfo in skillList)
                {
                    SkillLogic skillLogic = GetSkillLogic(skillInfo, self);
                    if (skillLogic != null)
                    {
                        int             skillId     = self.GetSkillID(skillInfo);
                        SkillConfig_New skillConfig = self.GetSkillConfig(skillId);
                        skillLogic.Tick(self, skillInfo, skillConfig);
                    }
                    else
                    {
                        self.LogInfo("something error2 {0}".F(self.GetSkillID(skillInfo)));
                    }
                }
            }
            //CD
            if (CDKeyList != null)
            {
                foreach (var key in CDKeyList)
                {
                    self.SetCD(key, self.GetCD(key) - self.GetDeltaTime());
                }
            }
        }
Exemple #3
0
        public static bool IsActionLimited(SkillObj self, ActionLimitType limit)
        {
            var skillList = self.GetSkillList();
            var buffList  = self.GetBuffList();

            //buff
            if (buffList != null)
            {
                foreach (var buffInfo in buffList)
                {
                    BuffLogic buffLogic = GetBuffLogic(buffInfo, self);
                    if (buffLogic != null)
                    {
                        int            buffId     = self.GetBuffID(buffInfo);
                        BuffConfig_New buffConfig = self.GetBuffConfig(buffId);
                        if (buffLogic.IsActionLimited(self, limit, buffInfo, buffConfig))
                        {
                            return(true);
                        }
                    }
                    else
                    {
                        self.LogInfo("something error {0}".F(self.GetBuffID(buffInfo)));
                    }
                }
            }
            //技能
            if (skillList != null)
            {
                foreach (var skillInfo in skillList)
                {
                    SkillLogic skillLogic = GetSkillLogic(skillInfo, self);
                    if (skillLogic != null)
                    {
                        int             skillId     = self.GetSkillID(skillInfo);
                        SkillConfig_New skillConfig = self.GetSkillConfig(skillId);
                        if (skillLogic.IsActionLimited(self, limit, skillInfo, skillConfig))
                        {
                            return(true);
                        }
                    }
                    else
                    {
                        self.LogInfo("something error2 {0}".F(self.GetSkillID(skillInfo)));
                    }
                }
            }
            return(false);
        }
Exemple #4
0
        private static BuffLogic GetBuffLogic(BuffInfo_New buffInfo, SkillObj logObj)
        {
            int            buffId     = logObj.GetBuffID(buffInfo);
            BuffConfig_New buffConfig = logObj.GetBuffConfig(buffId);

            if (buffConfig == null)
            {
                logObj.LogInfo("BuffConfig not found buffId[{0}]".F(buffId));
                return(null);
            }
            string buffLogicId = logObj.GetBuffLogicId(buffConfig);

            if (!BuffLogics.ContainsKey(buffLogicId))
            {
                logObj.LogInfo("BuffLogic not found buffId[{0}] buffLogicId[{1}]".F(buffId, buffLogicId));
                return(null);
            }
            BuffLogic buffLogic = BuffLogics[buffLogicId];

            return(buffLogic);
        }
Exemple #5
0
        /// <summary>
        /// 造成伤害或治疗
        /// </summary>
        /// <param name="tarObj"></param>
        /// <param name="srcObj"></param>
        /// <param name="damage">大于0是伤害,小于0是治疗</param>
        public static void DamageTarget(SkillObj tarObj, SkillObj srcObj, Damage damage)
        {
            SkillObj realSrcObj = srcObj;

            if (tarObj == null || tarObj.IsDead())
            {
                return;
            }
            if (realSrcObj != null && damage.srcId > 0 && realSrcObj.GetID() != damage.srcId)
            {
                realSrcObj = tarObj.GetSkillObj(damage.srcId);
            }
            BattleModule.CalcDamage(tarObj, realSrcObj, damage);
            //先修正伤害
            BattleModule.DamageFix(tarObj, realSrcObj, damage);
            //质量和造成伤害都是这个
            //造成伤害
            if (damage.value >= 0)
            {
                tarObj.OnDamage(damage, realSrcObj);
            }
            else
            {
                tarObj.OnDamage(damage, realSrcObj);
            }
            //检查技能与BUFF的相应触发
            if (realSrcObj != null && !realSrcObj.IsDead())
            {
                var srcSkillList = realSrcObj.GetSkillList();
                var srcBuffList  = realSrcObj.GetBuffList();
                //Source skill fix
                if (srcSkillList != null)
                {
                    foreach (var skillInfo in srcSkillList)
                    {
                        SkillLogic skillLogic = GetSkillLogic(skillInfo, realSrcObj);
                        int        skillId    = realSrcObj.GetSkillID(skillInfo);
                        if (skillLogic != null)
                        {
                            SkillConfig_New skillConfig = realSrcObj.GetSkillConfig(skillId);
                            if (damage.value >= 0)
                            {
                                skillLogic.OnDamageTarget(realSrcObj, tarObj, damage, skillInfo, skillConfig);
                            }
                            else
                            {
                                skillLogic.OnHealTarget(realSrcObj, tarObj, damage, skillInfo, skillConfig);
                            }
                        }
                        else
                        {
                            realSrcObj.LogInfo("something error in BattleModule.DamageTarget src skill:[{0}]".F(skillId));
                        }
                    }
                }
                //Source buff fix
                if (srcBuffList != null)
                {
                    foreach (var buffInfo in srcBuffList)
                    {
                        BuffLogic buffLogic = GetBuffLogic(buffInfo, realSrcObj);
                        int       buffId    = realSrcObj.GetBuffID(buffInfo);
                        if (buffLogic != null)
                        {
                            BuffConfig_New buffConfig = realSrcObj.GetBuffConfig(buffId);
                            if (damage.value >= 0)
                            {
                                buffLogic.OnDamageTarget(realSrcObj, tarObj, damage, buffInfo, buffConfig);
                            }
                            else
                            {
                                buffLogic.OnHealTarget(realSrcObj, tarObj, damage, buffInfo, buffConfig);
                            }
                        }
                        else
                        {
                            realSrcObj.LogInfo("something error in BattleModule.DamageTarget src buff:[{0}]".F(buffId));
                        }
                    }
                }
            }

            var tarSkillList = tarObj.GetSkillList();
            var tarBuffList  = tarObj.GetBuffList();

            //Target skill fix
            if (!tarObj.IsDead())
            {
                if (tarSkillList != null)
                {
                    foreach (var skillInfo in tarSkillList)
                    {
                        SkillLogic skillLogic = GetSkillLogic(skillInfo, tarObj);
                        int        skillId    = tarObj.GetSkillID(skillInfo);
                        if (skillLogic != null)
                        {
                            SkillConfig_New skillConfig = tarObj.GetSkillConfig(skillId);
                            if (damage.value >= 0)
                            {
                                skillLogic.OnBeHurt(tarObj, realSrcObj, damage, skillInfo, skillConfig);
                            }
                            else
                            {
                                skillLogic.OnBeHeal(tarObj, realSrcObj, damage, skillInfo, skillConfig);
                            }
                        }
                        else
                        {
                            tarObj.LogInfo("something error in BattleModule.DamageTarget tar skill:[{0}]".F(skillId));
                        }
                    }
                }
                //Target buff fix
                if (tarBuffList != null)
                {
                    foreach (var buffInfo in tarBuffList)
                    {
                        BuffLogic buffLogic = GetBuffLogic(buffInfo, tarObj);
                        int       buffId    = tarObj.GetBuffID(buffInfo);
                        if (buffLogic != null)
                        {
                            BuffConfig_New buffConfig = tarObj.GetBuffConfig(buffId);
                            if (damage.value >= 0)
                            {
                                buffLogic.OnBeHurt(tarObj, realSrcObj, damage, buffInfo, buffConfig);
                            }
                            else
                            {
                                buffLogic.OnBeHeal(tarObj, realSrcObj, damage, buffInfo, buffConfig);
                            }
                        }
                        else
                        {
                            tarObj.LogInfo("something error in BattleModule.DamageTarget tar buff:[{0}]".F(buffId));
                        }
                    }
                }
            }

            if (tarObj.IsDead())
            {
                if (tarSkillList != null)
                {
                    foreach (var skillInfo in tarSkillList)
                    {
                        SkillLogic skillLogic = GetSkillLogic(skillInfo, tarObj);
                        int        skillId    = tarObj.GetSkillID(skillInfo);
                        if (skillLogic != null)
                        {
                            SkillConfig_New skillConfig = tarObj.GetSkillConfig(skillId);
                            skillLogic.OnDie(tarObj, realSrcObj, skillInfo, skillConfig);
                        }
                        else
                        {
                            tarObj.LogInfo("something error in BattleModule.DamageTarget tar skill:[{0}]".F(skillId));
                        }
                    }
                }
                //Target buff fix
                if (tarBuffList != null)
                {
                    foreach (var buffInfo in tarBuffList)
                    {
                        BuffLogic buffLogic = GetBuffLogic(buffInfo, tarObj);
                        int       buffId    = tarObj.GetBuffID(buffInfo);
                        if (buffLogic != null)
                        {
                            BuffConfig_New buffConfig = tarObj.GetBuffConfig(buffId);
                            buffLogic.OnDie(tarObj, realSrcObj, buffInfo, buffConfig);
                        }
                        else
                        {
                            tarObj.LogInfo("something error in BattleModule.DamageTarget tar buff:[{0}]".F(buffId));
                        }
                    }
                }
                bool ret = tarObj.OnDie(realSrcObj);
            }
        }
Exemple #6
0
 private static void DamageFix(SkillObj tarObj, SkillObj srcObj, Damage damage)
 {
     if (tarObj == null)
     {
         return;
     }
     if (srcObj != null)
     {
         var srcSkillList = srcObj.GetSkillList();
         var srcBuffList  = srcObj.GetBuffList();
         //Source skill fix
         if (srcSkillList != null)
         {
             foreach (var skillInfo in srcSkillList)
             {
                 SkillLogic skillLogic = GetSkillLogic(skillInfo, srcObj);
                 int        skillId    = srcObj.GetSkillID(skillInfo);
                 if (skillLogic != null)
                 {
                     SkillConfig_New skillConfig = srcObj.GetSkillConfig(skillId);
                     skillLogic.DamageTargetFix(srcObj, tarObj, damage, skillInfo, skillConfig);
                 }
                 else
                 {
                     srcObj.LogInfo("something error in BattleModule.DamageFix src skill:[{0}]".F(skillId));
                 }
             }
         }
         //Source buff fix
         if (srcBuffList != null)
         {
             foreach (var buffInfo in srcBuffList)
             {
                 BuffLogic buffLogic = GetBuffLogic(buffInfo, srcObj);
                 int       buffId    = srcObj.GetBuffID(buffInfo);
                 if (buffLogic != null)
                 {
                     BuffConfig_New skillConfig = srcObj.GetBuffConfig(buffId);
                     buffLogic.DamageTargetFix(srcObj, tarObj, damage, buffInfo, skillConfig);
                 }
                 else
                 {
                     srcObj.LogInfo("something error in BattleModule.DamageFix src buff:[{0}]".F(buffId));
                 }
             }
         }
     }
     {
         var tarBuffList  = tarObj.GetBuffList();
         var tarSkillList = tarObj.GetSkillList();
         //Target skill fix
         if (tarSkillList != null)
         {
             foreach (var skillInfo in tarSkillList)
             {
                 SkillLogic skillLogic = GetSkillLogic(skillInfo, tarObj);
                 int        skillId    = tarObj.GetSkillID(skillInfo);
                 if (skillLogic != null)
                 {
                     SkillConfig_New skillConfig = tarObj.GetSkillConfig(skillId);
                     skillLogic.BeHurtDamageFix(tarObj, srcObj, damage, skillInfo, skillConfig);
                 }
                 else
                 {
                     tarObj.LogInfo("something error in BattleModule.DamageFix tar skill:[{0}]".F(skillId));
                 }
             }
         }
         //Target buff fix
         if (tarBuffList != null)
         {
             foreach (var buffInfo in tarBuffList)
             {
                 BuffLogic buffLogic = GetBuffLogic(buffInfo, tarObj);
                 int       buffId    = tarObj.GetBuffID(buffInfo);
                 if (buffLogic != null)
                 {
                     BuffConfig_New skillConfig = tarObj.GetBuffConfig(buffId);
                     buffLogic.BeHurtDamageFix(tarObj, srcObj, damage, buffInfo, skillConfig);
                 }
                 else
                 {
                     tarObj.LogInfo("something error in BattleModule.DamageFix tar buff:[{0}]".F(buffId));
                 }
             }
         }
     }
 }
Exemple #7
0
        public static void DetachBuff(SkillObj tarObj, SkillObj srcObj, BuffInfo_New buff, BuffConfig_New buffConfig)
        {
            var buffLogicId = tarObj.GetBuffLogicId(buffConfig);

            if (!BuffLogics.ContainsKey(buffLogicId))
            {
                return;
            }
            BuffLogic buffLogic = BuffLogics[buffLogicId];

            //先从src方进行修正
            if (srcObj != null)
            {
                var srcSkillList = srcObj.GetSkillList();
                var srcBuffList  = srcObj.GetBuffList();
                if (srcSkillList != null)
                {
                    foreach (var skillInfo in srcSkillList)
                    {
                        int             skillId     = srcObj.GetSkillID(skillInfo);
                        SkillConfig_New skillConfig = srcObj.GetSkillConfig(skillId);
                        var             logic       = GetSkillLogic(skillInfo, srcObj);
                        logic.OnClearBuff(tarObj, srcObj, buff, skillInfo, skillConfig);
                    }
                }
                if (srcBuffList != null)
                {
                    foreach (var buffInfo in srcBuffList)
                    {
                        int            buffId        = srcObj.GetBuffID(buffInfo);
                        BuffConfig_New srcBuffConfig = srcObj.GetBuffConfig(buffId);
                        var            logic         = GetBuffLogic(buffInfo, srcObj);
                        logic.OnClearBuff(tarObj, srcObj, buff, buffInfo, srcBuffConfig);
                    }
                }
            }
            {
                var tarSkillList = tarObj.GetSkillList();
                var tarBuffList  = tarObj.GetBuffList();
                if (tarSkillList != null)
                {
                    foreach (var skillInfo in tarSkillList)
                    {
                        int             skillId     = tarObj.GetSkillID(skillInfo);
                        SkillConfig_New skillConfig = tarObj.GetSkillConfig(skillId);
                        var             logic       = GetSkillLogic(skillInfo, tarObj);
                        logic.OnDetachBuff(tarObj, srcObj, buff, skillInfo, skillConfig);
                    }
                }
                if (tarBuffList != null)
                {
                    foreach (var buffInfo in tarBuffList.Where(b => b.buff != buff.buff))
                    {
                        int            buffId        = tarObj.GetBuffID(buffInfo);
                        BuffConfig_New tarBuffConfig = tarObj.GetBuffConfig(buffId);
                        var            logic         = GetBuffLogic(buffInfo, tarObj);
                        logic.OnDetachBuff(tarObj, srcObj, buff, buffInfo, tarBuffConfig);
                    }
                }
            }
            buffLogic.BuffOnEnd(tarObj, buff, buffConfig);
            buffLogic.OnDetach(tarObj, srcObj, buff, buffConfig);
        }
Exemple #8
0
        private BattleInitClass()
        {
            var asm = Assembly.GetExecutingAssembly();

            foreach (var b in asm.GetTypes())
            {
                if (b.IsSubclassOf(typeof(SkillLogic)))
                {
                    //自动填充SkillLogics
                    SkillLogic ins = asm.CreateInstance(b.FullName) as SkillLogic;
                    BattleModule.SkillLogics.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(SkillLogicState)))
                {
                    //自动填充SkillLogicStates
                    SkillLogicState ins = asm.CreateInstance(b.FullName) as SkillLogicState;
                    BattleModule.SkillLogicStates.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(TargetSelect)))
                {
                    //自动填充TargetSelect
                    TargetSelect ins = asm.CreateInstance(b.FullName) as TargetSelect;
                    BattleModule.TargetSelects.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(TargetType)))
                {
                    //自动填充TargetType
                    TargetType ins = asm.CreateInstance(b.FullName) as TargetType;
                    BattleModule.TargetTypes.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(BuffLogicState)))
                {
                    //自动填充BuffLogicStates
                    BuffLogicState ins = asm.CreateInstance(b.FullName) as BuffLogicState;
                    BattleModule.BuffLogicStates.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(BuffLogic)))
                {
                    //自动填充BuffLogicStates
                    BuffLogic ins = asm.CreateInstance(b.FullName) as BuffLogic;
                    BattleModule.BuffLogics.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(BuffSuperpositionLogic)))
                {
                    //自动填充BuffSuperpositionLogics
                    BuffSuperpositionLogic ins = asm.CreateInstance(b.FullName) as BuffSuperpositionLogic;
                    BattleModule.BuffSuperpositionLogics.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(SkillBulletMovingLogic)))
                {
                    //自动填充SkillBulletMovingLogic
                    SkillBulletMovingLogic ins = asm.CreateInstance(b.FullName) as SkillBulletMovingLogic;
                    BattleModule.SkillBulletMovingLogics.Add(b.Name, ins);
                }
                else if (b.IsSubclassOf(typeof(SkillBulletCollisionLogic)))
                {
                    //自动填充SkillBulletCollisionLogic
                    SkillBulletCollisionLogic ins = asm.CreateInstance(b.FullName) as SkillBulletCollisionLogic;
                    BattleModule.SkillBulletCollisionLogics.Add(b.Name, ins);
                }
            }
        }
Exemple #9
0
        public static bool AddBuff(SkillObj tarObj, SkillObj srcObj, int newBuffId, BattleReason reason)
        {
            if (tarObj == null)
            {
                return(false);
            }
            var buffConfig = tarObj.GetBuffConfig(newBuffId);

            if (buffConfig == null)
            {
                return(false);
            }

            var buffSuperpositionLogicId = tarObj.GetBuffSuperpositionLogicId(buffConfig);

            if (!BuffSuperpositionLogics.ContainsKey(buffSuperpositionLogicId))
            {
                return(false);
            }
            BuffSuperpositionLogic buffSuperpositionLogic = BuffSuperpositionLogics[buffSuperpositionLogicId];

            var          buffRet = buffSuperpositionLogic.OnBuffSuperposition(tarObj, srcObj, reason, buffConfig);
            BuffInfo_New buff    = buffRet.buff;

            if (buffRet.bType == BuffSuperpositionType.Refresh)
            {
                var buffLogicId = tarObj.GetBuffLogicId(buffConfig);
                if (!BuffLogics.ContainsKey(buffLogicId))
                {
                    return(false);
                }
                BuffLogic buffLogic = BuffLogics[buffLogicId];
                buffLogic.InitBuffInfo(tarObj, srcObj, reason, buff, buffConfig, false);
            }
            else if (buffRet.bType == BuffSuperpositionType.Add)
            {
                var buffLogicId = tarObj.GetBuffLogicId(buffConfig);
                if (!BuffLogics.ContainsKey(buffLogicId))
                {
                    return(false);
                }
                BuffLogic buffLogic = BuffLogics[buffLogicId];
                buffLogic.InitBuffInfo(tarObj, srcObj, reason, buff, buffConfig);

                //先从src方进行修正
                if (srcObj != null)
                {
                    var srcSkillList = srcObj.GetSkillList();
                    var srcBuffList  = srcObj.GetBuffList();
                    if (srcSkillList != null)
                    {
                        foreach (var skillInfo in srcSkillList)
                        {
                            int             skillId     = srcObj.GetSkillID(skillInfo);
                            SkillConfig_New skillConfig = srcObj.GetSkillConfig(skillId);
                            var             logic       = GetSkillLogic(skillInfo, srcObj);
                            logic.OnSendBuff(tarObj, srcObj, buff, skillInfo, skillConfig);
                        }
                    }
                    if (srcBuffList != null)
                    {
                        foreach (var buffInfo in srcBuffList)
                        {
                            int            buffId        = srcObj.GetBuffID(buffInfo);
                            BuffConfig_New srcBuffConfig = srcObj.GetBuffConfig(buffId);
                            var            logic         = GetBuffLogic(buffInfo, srcObj);
                            logic.OnSendBuff(tarObj, srcObj, buff, buffInfo, srcBuffConfig);
                        }
                    }
                }
                {
                    var tarSkillList = tarObj.GetSkillList();
                    var tarBuffList  = tarObj.GetBuffList();
                    if (tarSkillList != null)
                    {
                        foreach (var skillInfo in tarSkillList)
                        {
                            int             skillId     = tarObj.GetSkillID(skillInfo);
                            SkillConfig_New skillConfig = tarObj.GetSkillConfig(skillId);
                            var             logic       = GetSkillLogic(skillInfo, tarObj);
                            logic.OnAttachBuff(tarObj, srcObj, buff, skillInfo, skillConfig);
                        }
                    }
                    if (tarBuffList != null)
                    {
                        foreach (var buffInfo in tarBuffList)
                        {
                            int            buffId        = tarObj.GetBuffID(buffInfo);
                            BuffConfig_New tarBuffConfig = tarObj.GetBuffConfig(buffId);
                            var            logic         = GetBuffLogic(buffInfo, tarObj);
                            logic.OnAttachBuff(tarObj, srcObj, buff, buffInfo, tarBuffConfig);
                        }
                    }
                }
                buffLogic.OnAttach(tarObj, srcObj, buff, buffConfig);
                tarObj.AddTempBuffList(buff);
            }
            tarObj.NotifyBuffInfo(buff, BattleInfoNotifyType.All_Buff, BattleNotifyTime.TickEnd);
            return(true);
        }
Exemple #10
0
        public static bool RemoveBuff(SkillObj tarObj, SkillObj srcObj, int deleteBuffId, BattleReason reason)
        {
            if (tarObj == null)
            {
                return(false);
            }
            var buffConfig = tarObj.GetBuffConfig(deleteBuffId);

            if (buffConfig == null)
            {
                return(false);
            }

            var          tarBuffList = tarObj.GetBuffList();
            BuffInfo_New buff        = null;

            foreach (var b in tarBuffList)
            {
                if (tarObj.GetBuffID(b) == deleteBuffId)
                {
                    buff = b;
                    break;
                }
            }
            if (buff == null)
            {
                return(false);
            }
            //DetachBuff(tarObj, srcObj, buff, buffConfig);
            var buffLogicId = tarObj.GetBuffLogicId(buffConfig);

            if (!BuffLogics.ContainsKey(buffLogicId))
            {
                return(false);
            }
            BuffLogic buffLogic = BuffLogics[buffLogicId];

            buffLogic.BuffOnEnd(tarObj, buff, buffConfig);

            ////先从src方进行修正
            //if (srcObj != null)
            //{
            //	var srcSkillList = srcObj.GetSkillList();
            //	var srcBuffList = srcObj.GetBuffList();
            //	if (srcSkillList != null)
            //	{
            //		foreach (var skillInfo in srcSkillList)
            //		{
            //			int skillId = srcObj.GetSkillID(skillInfo);
            //			SkillConfig_New skillConfig = srcObj.GetSkillConfig(skillId);
            //			var logic = GetSkillLogic(skillInfo, srcObj);
            //			logic.OnClearBuff(tarObj, srcObj, buff, skillInfo, skillConfig);
            //		}
            //	}
            //	if (srcBuffList != null)
            //	{
            //		foreach (var buffInfo in srcBuffList)
            //		{
            //			int buffId = srcObj.GetBuffID(buffInfo);
            //			BuffConfig_New srcBuffConfig = srcObj.GetBuffConfig(buffId);
            //			var logic = GetBuffLogic(buffInfo, srcObj);
            //			logic.OnClearBuff(tarObj, srcObj, buff, buffInfo, srcBuffConfig);
            //		}
            //	}
            //}
            //{
            //	var tarSkillList = tarObj.GetSkillList();
            //	if (tarSkillList != null)
            //	{
            //		foreach (var skillInfo in tarSkillList)
            //		{
            //			int skillId = tarObj.GetSkillID(skillInfo);
            //			SkillConfig_New skillConfig = tarObj.GetSkillConfig(skillId);
            //			var logic = GetSkillLogic(skillInfo, tarObj);
            //			logic.OnDetachBuff(tarObj, srcObj, buff, skillInfo, skillConfig);
            //		}
            //	}
            //	if (tarBuffList != null)
            //	{
            //		foreach (var buffInfo in tarBuffList)
            //		{
            //			int buffId = tarObj.GetBuffID(buffInfo);
            //			BuffConfig_New tarBuffConfig = tarObj.GetBuffConfig(buffId);
            //			var logic = GetBuffLogic(buffInfo, tarObj);
            //			logic.OnDetachBuff(tarObj, srcObj, buff, buffInfo, tarBuffConfig);
            //		}
            //	}
            //}
            //buffLogic.BuffOnEnd(tarObj, buff, buffConfig);
            return(true);
        }