WSHCommon/XmdsVSPlugins/XmdsCommonSkill/Plugin/Buffs/XmdsBuff_Shield_AbsorbDamage.cs

using CommonAI.Zone.Instance;
using CommonAI.Zone.Formula;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using XmdsCommon.Plugin;
using XmdsCommonServer.Plugin;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.Skills;
using CommonAI.Zone;
using XmdsCommonSkill.Plugin.Interface;
using static XmdsCommonSkill.Plugin.Interface.ComSpellTemplate;
using CommonAI.Data;
using CommonAI.Zone.Helper;
using CommonLang;
using static CommonAI.Zone.Instance.InstanceUnit;

namespace XmdsCommonSkill.Plugin.Buffs
{
    /// <summary>
    /// FileName: XmdsBuff_Shield_AbsorbDamage.cs
    /// Author: Alex.Yu
    /// Corporation:... 
    /// Description: 护盾型吸收伤害.
    /// DateTime: 2015/6/8 21:05:08
    /// </summary>

    public class XmdsBuff_Shield_AbsorbDamage : XmdsBuffBase
    {
        /// <summary>
        /// 吸收伤害总量.
        /// </summary>
        public int AbsorbDamageSum = 0;

		public XmdsSpellID breakSpellID = 0;

		/** 触发频率 ms*/
		public int HitInterval = 0;

        /// <summary>
        /// 是否吸收过量伤害.
        /// </summary>
        public bool AbsorbOverFlowDamage = false;

		private long mNextHitTime;
        private int mHandleUUID = 0;

        public override int GetAbilityID()
        {
            return (int)XmdsCommon.Plugin.XmdsBuffProperties.XmdsBuffAbility.SHIELD_AbsorbDamage;
        }

		public override void CopyTo(UnitBuff other)
		{
			var ret = other as XmdsBuff_Shield_AbsorbDamage;

			ret.AbsorbDamageSum = this.AbsorbDamageSum;
			ret.AbsorbOverFlowDamage = this.AbsorbOverFlowDamage;
			ret.breakSpellID = this.breakSpellID;
			ret.HitInterval = this.HitInterval;
			base.CopyTo(other);
		}

		protected override void OnBuffBegin(XmdsCommonServer.Plugin.XmdsVirtual hitter, XmdsCommonServer.Plugin.XmdsVirtual attacker, InstanceUnit.BuffState state)
        {
            //注册监听.
            mHandleUUID = hitter.RegistOnHitDamage(OnHandleHitDmage, null);
            XmdsVirtual.FormatLog("BuffBegin : 单位【{0}】增加吸收伤害护盾.", hitter.mProp.ServerData.BaseInfo.name);
        }

        protected override void OnBuffEnd(XmdsCommonServer.Plugin.XmdsVirtual hitter, InstanceUnit.BuffState state, bool replace)
        {
            //取消监听.
            hitter.UnRegistOnHitDamage(mHandleUUID);
            XmdsVirtual.FormatLog("BuffBegin : 单位【{0}】失去吸收伤害护盾.", hitter.mProp.ServerData.BaseInfo.name);

			//护盾破碎，创建法术
			if(this.breakSpellID != 0)
			{
				//	//播放声音特效.
				hitter.mUnit.Parent.unitLaunchSpell(XmdsSkillType.none, hitter.mUnit,
                    ComSpellTemplate.Instance().GetSpellByID(this.breakSpellID),
                    hitter.mUnit.X, hitter.mUnit.Y, hitter.mUnit.ID);
			}
		}

        //单位被攻击时.伤害吸收计算.
        private float OnHandleHitDmage(float damage, XmdsVirtual hitted, XmdsVirtual attacker, AttackSource source, 
            ref XmdsVirtual.AtkResult result, DamageType damageType, GameSkill skill, ref bool isEndDispatch)
        {
            float ret = damage;

			if(this.mNextHitTime > CommonLang.CUtils.localTimeMS)
			{
				return damage;
			}

            //damage > 0是伤害，damage < 0是加血机制.
            if (damage > 0 && AbsorbDamageSum > 0)
            {
                ret = damage - AbsorbDamageSum;

                if (ret < 0)
                {
                    ret = 0;
                    source.OutClientState = (byte)XmdsCommonServer.Plugin.XmdsVirtual.UnitHitEventState.Absorb;
                }

                int abDamage = CUtils.CastInt(damage - ret);

                AbsorbDamageSum -= abDamage;

                if (AbsorbDamageSum <= 0)
                {
                    //破盾.
                    hitted.mUnit.removeBuff(BindBuffID, BuffState.ENDResult_HuDunBreak);

                    //过量伤害吸收.
                    if (AbsorbOverFlowDamage)
                    {
                        ret = 0;
                    }
                }

				//触发频率
				if(this.HitInterval > 0)
				{
					this.mNextHitTime = CommonLang.CUtils.localTimeMS + this.HitInterval;
				}

				this.OnAbsortDamage(hitted, attacker, source);

			}

            return ret;
        }

		protected virtual void OnAbsortDamage(XmdsVirtual hitted, XmdsVirtual attacker, AttackSource source)
		{

		}
    }
}