WSHCommon/XmdsCommonServer/Plugin/XmdsVirtual/XmdsVirtual.Damage.cs

using CommonAI.Data;
using CommonAI.Zone;
using CommonAI.Zone.Formula;
using CommonAI.ZoneServer.JSGModule;
using CommonLang;
using NPOI.SS.Formula;
using System;
using System.Collections.Generic;
using XmdsCommon.Message;
using XmdsCommon.Plugin;
using XmdsCommonServer.Plugin.Scene;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.DamageCalculator;
using XmdsCommonServer.Plugin.XmdsSkillTemplate.Skills;
using XmdsCommonServer.XLS;
using XmdsCommonServer.XLS.Data;

namespace XmdsCommonServer.Plugin
{
    /// <summary>
    /// FileName: XmdsVirtual.cs
    /// Author: Alex.Yu
    /// Corporation:... 
    /// Description: 用于伤害数值计算.
    /// DateTime: 2015/5/13 14:17:23
    /// </summary>
    partial class XmdsVirtual
    {

        /// <summary>
        /// 攻击结果.
        /// </summary>
        public enum UnitHitEventState
        {
            Normal = 0,					//普通攻击.
            Crit = 1,					//暴击.
            Dodge = 2,					//闪避.
            Parry = 3,					//招架.
            Absorb = 4,					//吸收.
            Immunity = 5,				//免疫.
            IronMaiden = 6,				//反伤.
            MP = 7,						//法力.
			KillMonsterCrit = 8,		//斩妖系统暴击	
        }

        /// <summary>
        /// 攻击结果：暴击、闪避、普通伤害.
        /// </summary>
        public enum AttackRlt : int
        {
            NoControl = -1,
            NormalAttack,
            CritAttack,
            ParryAttack,

        }

        //单位vs单位计算hit计算.
        private int On_hit_unit_vs_unit(XmdsVirtual attacker, XmdsVirtual hitter, AttackSource source, ref AtkResult result)
        {

            source.OutClientState = (int)UnitHitEventState.Normal;

            //是否为技能.
            bool isSkill = source.FromBuffState == null ? true : false;

            int damage = 0;

            //result.rlt = AttackRlt.NormalAttack;

            if (isSkill == false)
            {
                BuffTemplate template = source.FromBuffState.Data;
                //XmdsBuffProperties prop = template.Properties as XmdsBuffProperties;
                List<XmdsBuffVirtual> list = source.FromBuffState.Tag as List<XmdsBuffVirtual>;
                if (list != null)
                {
                    for (int i = 0; i < list.Count; i++)
                    {
                        UnitBuff ub = list[i] as UnitBuff;
                        damage += ub.BuffHit(hitter, attacker, source, ref result);
                    }
                }

                //分发事件单位收到伤害.
                damage = (int)hitter.DispatchHitDamageEvent(damage, attacker, source,ref result, template.IsHarmful ? DamageType.Damage : DamageType.Heal);
            }
            else
            {
                //1.计算攻击结果.2计算攻击伤害.
                damage = CalDamage(attacker, hitter, source, ref result);
            }


			damage += source.Attack.Attack;

			//设置结果.
			switch (source.OutClientState)
            {
                case (int)UnitHitEventState.Dodge:
                    //source.OutClientState = (int)UnitHitEventState.Dodge;
                    XmdsAttackProperties prop = (source.Attack.Properties as XmdsAttackProperties);
                    FormatLog("{0}对目标{1}使用技能【{2}】被目标【闪避】", attacker.mInfo.Name, hitter.mInfo.Name, prop.SkillTemplateID);
                    damage = 0;
                    break;
                case (int)UnitHitEventState.Crit:
                    //source.OutClientState = (int)UnitHitEventState.Crit;
                    FormatLog("【{0}】攻击【{1}】结果 =【{2}】，伤害 =【{3}】", attacker.mInfo.Name, hitter.mInfo.Name, "暴击", damage);
                    break;
                case (int)UnitHitEventState.Normal:
                    //source.OutClientState = (int)UnitHitEventState.Normal;
                    FormatLog("【{0}】攻击【{1}】结果 =【{2}】，伤害 =【{3}】", attacker.mInfo.Name, hitter.mInfo.Name, "普攻", damage);
                    break;
                case (int)UnitHitEventState.Immunity:
                    //source.OutClientState = (int)UnitHitEventState.Normal;
                    FormatLog("【{0}】攻击【{1}】结果 =【{2}】，伤害 =【{3}】", attacker.mInfo.Name, hitter.mInfo.Name, "免疫", damage);
                    break;
                case (int)UnitHitEventState.Absorb:
                    //source.OutClientState = (int)UnitHitEventState.Normal;
                    FormatLog("【{0}】攻击【{1}】结果 =【{2}】，伤害 =【{3}】", attacker.mInfo.Name, hitter.mInfo.Name, "吸收", damage);
                    break;
                case (int)UnitHitEventState.IronMaiden:
                    //source.OutClientState = (int)UnitHitEventState.Normal;
                    FormatLog("【{0}】攻击【{1}】结果 =【{2}】，伤害 =【{3}】", attacker.mInfo.Name, hitter.mInfo.Name, "反伤", damage);
                    break;
                default:
                    break;
            }

            if (damage == 0)
            {
                //闪避时不产生受击.
                //source.OutIsDamage = false;
            }
			else
			{
				hitter.mUnit.mLastDamageTime = CommonLang.CUtils.localTimeMS;
				attacker.mUnit.mLastHitOtherTime = CommonLang.CUtils.localTimeMS;
			}

            return damage;
        }

        /// <summary>
        /// 纷发单位打到其他单位，其他单位被攻击，(XmdsSkillBase调用).
        /// </summary>
        /// <param name="damage"></param>
        /// <param name="attacker"></param>
        /// <param name="hitter"></param>
        /// <param name="source"></param>
        public void DispatchHitEvents(ref int damage, XmdsVirtual attacker, XmdsVirtual hitter, AttackSource source, 
            ref XmdsVirtual.AtkResult result, DamageType damageType)
        {
			//分发事件单位打到别人.
			damage = (int)attacker.DispatchHitOtherEvent(damage, hitter, source, ref result, damageType);

			//分发事件单位收到伤害.
			damage = (int)hitter.DispatchHitDamageEvent(damage, attacker, source, ref result, damageType);

			//分发卡牌时间
			attacker.mCardModule.OnHitOther(hitter, source);
			hitter.mCardModule.OnHitDamage(attacker, source);
		}

        private int CalDamage(XmdsVirtual attacker, XmdsVirtual hitter, AttackSource source, ref AtkResult result)
        {
            int ret = 0;

			//攻击者调用计算伤害.
			attacker.DispatchSkillDamageEvent(attacker, hitter, source);
			ret = attacker.DispatchCalDamageEvent(hitter, source, ref result);

            return ret;
        }

        /// <summary>
        /// 伤害计算扩展类.
        /// </summary>
        public struct AtkResult
        {
            ///// <summary>
            ///// 攻击结果.
            ///// </summary>
            //public AttackRlt rlt;
            public int ThreatValue { get; set; }

            /// <summary>
            /// 更改百分比.
            /// </summary>
            public int ThreatValueChangePer { get; set; }

            /// <summary>
            /// 更改绝对值.
            /// </summary>
            public int ThreatValueChangeModify { get; set; }

			//破定值
			public int breakShieldValue;
        }

		protected void dynamicCalcBy(XmdsUnitProp ret, float hp, float atk, float def, float crit, float CritDamage, float ignoreDef)
		{
			ret.BaseMaxHP = (int)(ret.BaseMaxHP * hp);
			ret.BaseAttack = (int)(ret.BaseAttack * atk);
			ret.BaseDefence = (int)(ret.BaseDefence * def);
			ret.CritRate = (int)(ret.CritRate * crit);
			ret.CritDamage = (int)(ret.CritDamage * CritDamage);
			ret.IgnoreDefensePer = (int)(ret.IgnoreDefensePer * ignoreDef);
		}

		protected void restoreMa2Ret(XmdsUnitProp ret, MonsterData ma)
		{
			if (ma.MaxHP != -1)
			{
				ret.BaseMaxHP = ma.MaxHP;
			}

			if (ma.MaxAttack != -1)
			{
				ret.BaseAttack = ma.MaxAttack;
			}

			if (ma.MaxDefence != -1)
			{
				ret.BaseDefence = ma.MaxDefence;
			}

			if (ma.CritRate != -1)
			{
				ret.CritRate = ma.CritRate;
			}

			if (ma.CritDamage != -1)
			{
				ret.CritDamage = ma.CritDamage;
			}

			if (ma.IgnoreDefencePer != -1)
			{
				ret.IgnoreDefensePer = ma.IgnoreDefencePer;
			}
		}

		protected void initProp(MonsterProp prop, MonsterData ma, XmdsUnitProp ret)
		{
			ret.BaseMaxHP = prop.MaxHP;
			ret.HP = prop.MaxHP;

			ret.BaseAttack = prop.Attack;
			ret.BaseDefence = prop.Def;
			ret.CritRate = prop.CritRate;
			ret.CritDamage = prop.CritDamage;
			ret.IgnoreDefensePer = prop.IgnoreDefensePer;

			this.mProp.ServerData.BaseInfo.UnitLv = prop.Mon_Level;
			this.mUnit.Level = prop.Mon_Level;
		}

		protected void initProp2(MonsterData ma, OrigData oData, UserDefineConfig udc, XmdsUnitProp ret)
		{
			UserDefineConfig config = XmdsDataMgr.GetInstance().mMonsterDynamicLoader.GetUserDefineConfig(ma.Type);
			float atkTemp = oData.Atk * config.Atk_Ratio;
			float defTemp = oData.Def * config.Def_Ratio;
			float hpTemp = oData.Hp * config.HP_Ratio;
			float critTemp = oData.CritRate * config.Crit_Ratio;
			float critDamageTemp = oData.CritDamage * config.CritDamage_Ratio;
			float ignoreDefTemp = oData.IgnoreDefensePer * config.IgnoreDef_Ratio;
			//防御值 * （1 — 穿透值）
			float drdaTemp1 = defTemp * (1 - ignoreDefTemp / XmdsDamageCalculator.PERER);
			//暴击值 * 爆伤值 + 1 - 暴击值
			float drdaTemp2 = (critTemp / XmdsDamageCalculator.PERER * critDamageTemp / XmdsDamageCalculator.PERER + 1
				- critTemp / XmdsDamageCalculator.PERER);
			//XmdsDamageCalculator.GetDefByLevel是获得该等级的防御基础值。人物的那个映射表
			// 43428, 43428, 45437, 47936, 50852, 54111, 57633, 61315, 65018, 68550, 71651, 73963, 75000
			float drda = 1 - (drdaTemp1 / (drdaTemp1 + XmdsDamageCalculator.GetDefByLevel(ma.Level)));

			ret.BaseMaxHP = (int)(ma.Fight_Count * ma.AliveTime * atkTemp * drda * drdaTemp2);

			float hpParma = ma.KillPlayerTime;// * drda * drdaTemp2;
			ret.BaseAttack = (int)(hpParma == 0 ? hpTemp : (hpTemp / hpParma));

			ret.BaseDefence = (int)defTemp;
			ret.CritRate = (int)(critTemp);
			ret.CritDamage = (int)(critDamageTemp);
			ret.IgnoreDefensePer = (int)(ignoreDefTemp);
		}
	}
}