From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../Scripts/XMainClient/CombatEffectHelper.cs | 1055 ++++++++++++++++++++ 1 file changed, 1055 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/CombatEffectHelper.cs (limited to 'Client/Assets/Scripts/XMainClient/CombatEffectHelper.cs') diff --git a/Client/Assets/Scripts/XMainClient/CombatEffectHelper.cs b/Client/Assets/Scripts/XMainClient/CombatEffectHelper.cs new file mode 100644 index 00000000..2eb3b7c0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/CombatEffectHelper.cs @@ -0,0 +1,1055 @@ +using System; +using System.Collections.Generic; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class CombatEffectHelper : XDataBase + { + public BuffTable.RowData BuffInfo + { + get + { + return this.m_pBuffInfo; + } + } + + public EffectDataParams EffectData + { + get + { + return this.m_pEffectData; + } + } + + public CombatEffectType CacheQueryType + { + get + { + return this.m_CacheType; + } + } + + public EffectDataParams.TypeDataCollection CacheTypeDataCollection + { + get + { + return this.m_CacheCollection; + } + } + + private BuffTable.RowData m_pBuffInfo; + + private EffectDataParams m_pEffectData; + + private uint m_SkillHash; + + private uint m_ActualSkillHash; + + private CombatEffectType m_CacheType; + + private EffectDataParams.TypeDataCollection m_CacheCollection; + + private Dictionary m_Template2BuffTable = new Dictionary(); + + private static float[] startDataBufferFloat = new float[10]; + + private static float[] curDataBufferFloat = new float[10]; + + private static uint[] startDataBufferUint = new uint[10]; + + private static uint[] curDataBufferUint = new uint[10]; + + public static readonly char[] ConstantSeparator = new char[] + { + '^' + }; + + private struct GetSeqDataParam + { + public CombatEffectHelper helper; + + public int dim; + + public CombatEffectType type; + + public int replaceIndex; + + public double ratio; + + public GetSeqDataParam(int dimension) + { + this.helper = null; + this.dim = dimension; + this.type = CombatEffectType.CET_INVALID; + this.replaceIndex = 0; + this.ratio = 0.0; + } + } + + private struct GetSeqListDataParam + { + public CombatEffectHelper helper; + + public int dim; + + public CombatEffectType type; + + public int replaceIndex; + + public double ratio; + + public GetSeqListDataParam(int dimension) + { + this.helper = null; + this.dim = dimension; + this.type = CombatEffectType.CET_INVALID; + this.replaceIndex = 0; + this.ratio = 0.0; + } + } + + private struct GetSeqListDataFromVecStringParam + { + public CombatEffectHelper helper; + + public int dim; + + public CombatEffectType type; + + public int replaceIndex; + + public int hashIndex; + + public GetSeqListDataFromVecStringParam(int dimension) + { + this.helper = null; + this.dim = dimension; + this.type = CombatEffectType.CET_INVALID; + this.replaceIndex = 0; + this.hashIndex = 0; + } + } + + public void SetCacheQuery(CombatEffectType type, EffectDataParams.TypeDataCollection collection) + { + this.m_CacheType = type; + this.m_CacheCollection = collection; + } + + public void ClearCache() + { + this.m_CacheCollection = null; + this.m_CacheType = CombatEffectType.CET_INVALID; + } + + public BuffTable.RowData GetTemplateBuffTable(uint templateBuffID) + { + BuffTable.RowData buffData; + bool flag = this.m_Template2BuffTable.TryGetValue(templateBuffID, out buffData); + BuffTable.RowData result; + if (flag) + { + result = buffData; + } + else + { + buffData = XSingleton.singleton.GetBuffData((int)templateBuffID, 1); + this.m_Template2BuffTable[templateBuffID] = buffData; + result = buffData; + } + return result; + } + + public override void Recycle() + { + base.Recycle(); + this.m_Template2BuffTable.Clear(); + this.m_pBuffInfo = null; + this.m_pEffectData = null; + this.m_SkillHash = 0u; + this.m_ActualSkillHash = 0u; + this.m_CacheType = CombatEffectType.CET_INVALID; + this.m_CacheCollection = null; + } + + private bool _IsValidEntity(XEntity entity) + { + bool flag = entity == null || entity.Deprecated || entity.Destroying || entity.Attributes == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = !entity.IsPlayer; + if (flag2) + { + bool flag3 = entity.Attributes.FinalHostID == 0UL; + if (flag3) + { + return false; + } + XEntity entityConsiderDeath = XSingleton.singleton.GetEntityConsiderDeath(entity.Attributes.FinalHostID); + bool flag4 = entityConsiderDeath == null || !entityConsiderDeath.IsPlayer; + if (flag4) + { + return false; + } + } + result = true; + } + return result; + } + + public void Set(BuffTable.RowData pBuffInfo, ulong casterID, XEntity defaultEntity) + { + bool flag = casterID == 0UL || defaultEntity == null || casterID == defaultEntity.ID; + if (flag) + { + this.Set(pBuffInfo, defaultEntity); + } + else + { + this.Set(pBuffInfo, XSingleton.singleton.GetEntityConsiderDeath(casterID)); + } + } + + public void Set(BuffTable.RowData pBuffInfo, XEntity entity) + { + this.m_SkillHash = 0u; + this.m_ActualSkillHash = 0u; + this.m_pBuffInfo = pBuffInfo; + this.m_CacheType = CombatEffectType.CET_INVALID; + this.m_CacheCollection = null; + this.m_Template2BuffTable.Clear(); + bool flag = !this._IsValidEntity(entity) || !XSingleton.singleton.IsArtifactEnabled(); + if (!flag) + { + this.m_pEffectData = XSingleton.singleton.GetEffectDataByBuff((uint)pBuffInfo.BuffID); + } + } + + public void Set(string skillName, XEntity entity) + { + this.Set(XSingleton.singleton.XHash(skillName), entity); + } + + public void Set(uint skillHash, XEntity entity) + { + this.m_SkillHash = skillHash; + this.m_ActualSkillHash = skillHash; + this.m_pBuffInfo = null; + this.m_CacheType = CombatEffectType.CET_INVALID; + this.m_CacheCollection = null; + this.m_Template2BuffTable.Clear(); + bool flag = !this._IsValidEntity(entity) || !XSingleton.singleton.IsArtifactEnabled(); + if (!flag) + { + this.m_pEffectData = XSingleton.singleton.GetEffectDataBySkill(skillHash); + bool flag2 = this.m_pEffectData == null; + if (flag2) + { + uint preSkill = XSingleton.singleton.GetPreSkill(skillHash, entity.SkillCasterTypeID); + bool flag3 = preSkill > 0u; + if (flag3) + { + this.m_pEffectData = XSingleton.singleton.GetEffectDataBySkill(preSkill); + this.m_ActualSkillHash = preSkill; + } + } + } + } + + private static EffectDataParams.TypeDataCollection GetTypeDataList(CombatEffectType type, CombatEffectHelper helper) + { + bool flag = helper.CacheQueryType == type; + EffectDataParams.TypeDataCollection result; + if (flag) + { + result = helper.CacheTypeDataCollection; + } + else + { + bool flag2 = helper.EffectData == null; + if (flag2) + { + result = null; + } + else + { + EffectDataParams.TypeDataCollection collection = helper.EffectData.GetCollection(type); + bool flag3 = collection == null; + if (flag3) + { + result = null; + } + else + { + helper.SetCacheQuery(type, collection); + result = collection; + } + } + } + return result; + } + + public bool bHasEffect(CombatEffectType type) + { + return CombatEffectHelper.GetTypeDataList(type, this) != null; + } + + private int GetSum(CombatEffectType type) + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(type, this); + bool flag = typeDataList == null; + int result; + if (flag) + { + result = 0; + } + else + { + int num = 0; + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + for (int j = 0; j < typeData.randomParams.Count; j++) + { + num += typeData.randomParams[j]; + } + } + result = num; + } + return result; + } + + private bool GetSequenceSum(ref CombatEffectHelper.GetSeqDataParam param, SequenceList vecOut, GetBuffDataSeqFloat getBuffDataDelegate, int dim) + { + bool flag = param.replaceIndex >= param.dim; + bool result; + if (flag) + { + result = false; + } + else + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(param.type, param.helper); + bool flag2 = typeDataList == null; + if (flag2) + { + result = false; + } + else + { + vecOut.Reset((short)param.dim, (int)((short)typeDataList.datas.Count)); + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + BuffTable.RowData rowData = (typeData.templatebuffID == 0u) ? param.helper.BuffInfo : param.helper.GetTemplateBuffTable(typeData.templatebuffID); + bool flag3 = rowData == null; + if (!flag3) + { + bool flag4 = typeData.randomParams.Count == 0; + if (!flag4) + { + bool flag5 = getBuffDataDelegate != null; + if (flag5) + { + bool flag6 = !this._ReplaceSeq(getBuffDataDelegate(rowData), (float)((double)typeData.randomParams[0] * param.ratio), param.replaceIndex, vecOut, i, dim); + if (flag6) + { + return false; + } + } + } + } + } + result = true; + } + } + return result; + } + + private bool GetVecSequenceSum(ref CombatEffectHelper.GetSeqListDataParam param, SequenceList vecOut, GetBuffDataSeqListFloat getBuffDataDelegate, int dim) + { + bool flag = param.replaceIndex >= param.dim; + bool result; + if (flag) + { + result = false; + } + else + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(param.type, param.helper); + bool flag2 = typeDataList == null; + if (flag2) + { + result = false; + } + else + { + vecOut.CheckOrReset((short)param.dim); + int count = vecOut.Count; + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + BuffTable.RowData rowData = (typeData.templatebuffID == 0u) ? param.helper.BuffInfo : param.helper.GetTemplateBuffTable(typeData.templatebuffID); + bool flag3 = rowData == null; + if (!flag3) + { + bool flag4 = getBuffDataDelegate != null; + if (flag4) + { + bool flag5 = !this._ReplaceVecSeq(ref param, getBuffDataDelegate(rowData), typeData.randomParams, vecOut, ref count, dim); + if (flag5) + { + return false; + } + } + } + } + result = true; + } + } + return result; + } + + private bool GetVecSequenceSum(ref CombatEffectHelper.GetSeqListDataParam param, SequenceList vecOut, GetBuffDataSeqListInt getBuffDataDelegate, int dim) + { + bool flag = param.replaceIndex >= param.dim; + bool result; + if (flag) + { + result = false; + } + else + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(param.type, param.helper); + bool flag2 = typeDataList == null; + if (flag2) + { + result = false; + } + else + { + vecOut.CheckOrReset((short)param.dim); + int count = vecOut.Count; + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + BuffTable.RowData rowData = (typeData.templatebuffID == 0u) ? param.helper.BuffInfo : param.helper.GetTemplateBuffTable(typeData.templatebuffID); + bool flag3 = rowData == null; + if (!flag3) + { + bool flag4 = getBuffDataDelegate != null; + if (flag4) + { + bool flag5 = !this._ReplaceVecSeq(ref param, getBuffDataDelegate(rowData), typeData.randomParams, vecOut, ref count, dim); + if (flag5) + { + return false; + } + } + } + } + result = true; + } + } + return result; + } + + private bool GetVecSequenceSumFromVecString(ref CombatEffectHelper.GetSeqListDataFromVecStringParam param, SequenceList vecOut, GetBuffDataSeqListString getBuffDataDelegate, int dim) + { + bool flag = param.replaceIndex >= param.dim; + bool result; + if (flag) + { + result = false; + } + else + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(param.type, param.helper); + bool flag2 = typeDataList == null; + if (flag2) + { + result = false; + } + else + { + vecOut.CheckOrReset((short)param.dim); + int count = vecOut.Count; + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + BuffTable.RowData rowData = (typeData.templatebuffID == 0u) ? param.helper.BuffInfo : param.helper.GetTemplateBuffTable(typeData.templatebuffID); + bool flag3 = rowData == null; + if (!flag3) + { + bool flag4 = getBuffDataDelegate != null; + if (flag4) + { + bool flag5 = !this._ReplaceVecSeqFromVecString(ref param, getBuffDataDelegate(rowData), typeData.randomParams, vecOut, ref count, dim); + if (flag5) + { + return false; + } + } + } + } + result = true; + } + } + return result; + } + + private float _Double2Float(double d) + { + return (float)d; + } + + private uint _Double2Uint(double d) + { + return (uint)d; + } + + private int _Double2Int(double d) + { + return (int)d; + } + + private uint _Uint2Uint(uint u) + { + return u; + } + + private uint _Int2Uint(int u) + { + return (uint)u; + } + + private bool _ReplaceSeq(T refData, N value, int replaceIndex, SequenceList vecOut, int dataIndex, int dim) where T : ISeqRef where N : IComparable + { + bool flag = dim <= replaceIndex; + bool result; + if (flag) + { + result = false; + } + else + { + for (int i = 0; i < dim; i++) + { + bool flag2 = i == replaceIndex; + if (flag2) + { + vecOut[dataIndex, replaceIndex] = value; + } + else + { + vecOut[dataIndex, i] = refData[i]; + } + } + result = true; + } + return result; + } + + private bool _ReplaceSeq(ISeqRef refData, N value, int replaceIndex, SequenceList vecOut, int dataIndex, int dim) + { + bool flag = dim <= replaceIndex; + bool result; + if (flag) + { + result = false; + } + else + { + for (int i = 0; i < dim; i++) + { + bool flag2 = i == replaceIndex; + if (flag2) + { + vecOut[dataIndex, replaceIndex] = value; + } + else + { + vecOut[dataIndex, i] = refData[i]; + } + } + result = true; + } + return result; + } + + private bool _ReplaceVecSeq(ref CombatEffectHelper.GetSeqListDataParam param, ISeqListRef refData, List values, SequenceList vecOut, ref int index, int dim) + { + bool flag = param.replaceIndex >= dim || (refData.Count != 0 && refData.Count != values.Count); + bool result; + if (flag) + { + result = false; + } + else + { + int i = 0; + while (i < refData.Count) + { + for (int j = 0; j < dim; j++) + { + bool flag2 = j == param.replaceIndex; + if (flag2) + { + vecOut[index, j] = (float)((double)values[i] * param.ratio); + } + else + { + vecOut[index, j] = refData[i, j]; + } + } + i++; + index++; + } + result = true; + } + return result; + } + + private bool _ReplaceVecSeq(ref CombatEffectHelper.GetSeqListDataParam param, ISeqListRef refData, List values, SequenceList vecOut, ref int index, int dim) + { + bool flag = param.replaceIndex >= dim || (refData.Count != 0 && refData.Count != values.Count); + bool result; + if (flag) + { + result = false; + } + else + { + int i = 0; + while (i < refData.Count) + { + for (int j = 0; j < dim; j++) + { + bool flag2 = j == param.replaceIndex; + if (flag2) + { + vecOut[index, j] = (int)((double)values[i] * param.ratio); + } + else + { + vecOut[index, j] = refData[i, j]; + } + } + i++; + index++; + } + result = true; + } + return result; + } + + private bool _ReplaceVecSeqFromVecString(ref CombatEffectHelper.GetSeqListDataFromVecStringParam param, ISeqListRef refData, List values, SequenceList vecOut, ref int index, int dim) + { + bool flag = param.replaceIndex >= dim || (refData.Count != 0 && refData.Count != values.Count); + bool result; + if (flag) + { + result = false; + } + else + { + int i = 0; + while (i < refData.Count) + { + for (int j = 0; j < dim; j++) + { + bool flag2 = j == param.replaceIndex; + if (flag2) + { + vecOut[index, j] = (uint)values[i]; + } + else + { + bool flag3 = j == param.hashIndex; + if (flag3) + { + vecOut[index, j] = XSingleton.singleton.XHash(refData[i, j]); + } + else + { + vecOut[index, j] = uint.Parse(refData[i, j]); + } + } + } + i++; + index++; + } + result = true; + } + return result; + } + + public static float Add(float left, float right) + { + return left + right; + } + + public static int Add(int left, int right) + { + return left + right; + } + + public static uint Add(uint left, uint right) + { + return left + right; + } + + private bool _CompareSeq(T[] left, T[] right, int exclusiveIndex) where T : IComparable + { + bool flag = left.Length != right.Length; + bool result; + if (flag) + { + result = false; + } + else + { + for (int i = 0; i < left.Length; i++) + { + bool flag2 = i == exclusiveIndex; + if (!flag2) + { + bool flag3 = left[i].CompareTo(right[i]) != 0; + if (flag3) + { + return false; + } + } + } + result = true; + } + return result; + } + + public void Merge(SequenceList datas, int exclusiveIndex) + { + int num = 0; + int num2 = 1; + float[] array = CombatEffectHelper.startDataBufferFloat; + float[] array2 = CombatEffectHelper.curDataBufferFloat; + while (num < datas.Count && num2 < datas.Count) + { + datas.Get(num2, array2); + int num3 = -1; + for (int i = 0; i <= num; i++) + { + datas.Get(i, array); + bool flag = this._CompareSeq(array, array2, exclusiveIndex); + if (flag) + { + num3 = i; + break; + } + } + bool flag2 = num3 != -1; + if (flag2) + { + datas[num3, exclusiveIndex] = array2[exclusiveIndex] + datas[num3, exclusiveIndex]; + } + else + { + num++; + bool flag3 = num < num2; + if (flag3) + { + datas.Set(num, array2); + } + } + num2++; + } + datas.Trim(num + 1); + } + + public void Merge(SequenceList datas, int exclusiveIndex) + { + int num = 0; + int num2 = 1; + uint[] array = CombatEffectHelper.startDataBufferUint; + uint[] array2 = CombatEffectHelper.curDataBufferUint; + while (num < datas.Count && num2 < datas.Count) + { + datas.Get(num2, array2); + int num3 = -1; + for (int i = 0; i <= num; i++) + { + datas.Get(i, array); + bool flag = this._CompareSeq(array, array2, exclusiveIndex); + if (flag) + { + num3 = i; + break; + } + } + bool flag2 = num3 != -1; + if (flag2) + { + datas[num3, exclusiveIndex] = array2[exclusiveIndex] + datas[num3, exclusiveIndex]; + } + else + { + num++; + bool flag3 = num < num2; + if (flag3) + { + datas.Set(num, array2); + } + } + num2++; + } + datas.Trim(num + 1); + } + + private ISeqRef _GetBuffHPData(BuffTable.RowData pBuffData) + { + return pBuffData.BuffHP; + } + + public bool GetBuffHP(SequenceList vecOut) + { + CombatEffectHelper.GetSeqDataParam getSeqDataParam; + getSeqDataParam.dim = 2; + getSeqDataParam.helper = this; + getSeqDataParam.ratio = 1.0; + getSeqDataParam.replaceIndex = 1; + getSeqDataParam.type = CombatEffectType.CET_Buff_HP; + return this.GetSequenceSum(ref getSeqDataParam, vecOut, new GetBuffDataSeqFloat(this._GetBuffHPData), 2); + } + + private ISeqListRef _GetBuffChangeAttributeData(BuffTable.RowData pBuffData) + { + return pBuffData.BuffChangeAttribute; + } + + public bool GetBuffChangeAttribute(SequenceList vecOut) + { + CombatEffectHelper.GetSeqListDataParam getSeqListDataParam; + getSeqListDataParam.dim = 3; + getSeqListDataParam.helper = this; + getSeqListDataParam.ratio = 0.001; + getSeqListDataParam.replaceIndex = 1; + getSeqListDataParam.type = CombatEffectType.CET_Buff_ChangeAttribute; + bool vecSequenceSum = this.GetVecSequenceSum(ref getSeqListDataParam, vecOut, new GetBuffDataSeqListFloat(this._GetBuffChangeAttributeData), 3); + this.Merge(vecOut, 1); + return vecSequenceSum; + } + + public bool GetSkillDamage(out float ratio) + { + ratio = 0f; + int sum = this.GetSum(CombatEffectType.CET_Skill_Damage); + bool flag = sum == 0; + bool result; + if (flag) + { + result = false; + } + else + { + ratio = (float)sum * 0.001f; + result = true; + } + return result; + } + + public bool GetSkillCD(out float fOut) + { + fOut = 0f; + int sum = this.GetSum(CombatEffectType.CET_Skill_CD); + bool flag = sum == 0; + bool result; + if (flag) + { + result = false; + } + else + { + fOut = (float)sum * 0.001f; + bool flag2 = fOut > 1f; + if (flag2) + { + fOut = 1f; + } + fOut = -fOut; + result = true; + } + return result; + } + + public float GetBuffAuraRadius() + { + return (float)this.GetSum(CombatEffectType.CET_Buff_AuraRadius) * 0.001f; + } + + public float GetBuffTriggerRate() + { + return (float)this.GetSum(CombatEffectType.CET_Buff_TriggerRate) * 0.001f; + } + + public float GetBuffDuration() + { + return (float)this.GetSum(CombatEffectType.CET_Buff_Duration) * 0.001f; + } + + public bool GetSkillAddBuff(ref List vecBuffs, XSkillFlags flags) + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(CombatEffectType.CET_Skill_AddBuff, this); + bool flag = typeDataList == null; + bool result; + if (flag) + { + result = false; + } + else + { + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + for (int j = 0; j < typeData.constantParams.Count; j++) + { + string[] array = typeData.constantParams[j].Split(CombatEffectHelper.ConstantSeparator); + bool flag2 = array.Length >= 4 && flags != null && !flags.IsFlagSet(uint.Parse(array[3])); + if (!flag2) + { + bool flag3 = array.Length == 0; + if (!flag3) + { + BuffDesc item; + item.BuffID = int.Parse(array[0]); + item.BuffLevel = ((array.Length >= 2) ? int.Parse(array[1]) : 1); + item.DelayTime = ((array.Length >= 3) ? float.Parse(array[2]) : 0f); + item.SkillID = this.m_SkillHash; + item.EffectTime = BuffDesc.DEFAULT_TIME; + item.CasterID = 0UL; + bool flag4 = vecBuffs == null; + if (flag4) + { + vecBuffs = new List(); + } + vecBuffs.Add(item); + } + } + } + } + result = true; + } + return result; + } + + public bool GetSkillAddMobBuff(int skillLevel, List vecBuffs) + { + EffectDataParams.TypeDataCollection typeDataList = CombatEffectHelper.GetTypeDataList(CombatEffectType.CET_Skill_AddMobBuff, this); + bool flag = typeDataList == null; + bool result; + if (flag) + { + result = false; + } + else + { + for (int i = 0; i < typeDataList.datas.Count; i++) + { + EffectDataParams.TypeData typeData = typeDataList.datas[i]; + for (int j = 0; j < typeData.constantParams.Count; j++) + { + string[] array = typeData.constantParams[j].Split(CombatEffectHelper.ConstantSeparator); + bool flag2 = array.Length == 0; + if (!flag2) + { + BuffDesc item; + item.BuffID = int.Parse(array[0]); + item.BuffLevel = ((array.Length >= 2) ? int.Parse(array[1]) : skillLevel); + item.DelayTime = 0f; + item.SkillID = 0u; + item.EffectTime = BuffDesc.DEFAULT_TIME; + item.CasterID = 0UL; + vecBuffs.Add(item); + } + } + } + result = true; + } + return result; + } + + private ISeqListRef _GetBuffReduceSkillCDData(BuffTable.RowData pBuffData) + { + return pBuffData.ReduceSkillCD; + } + + public bool GetBuffReduceSkillCD(SequenceList vecOut) + { + CombatEffectHelper.GetSeqListDataFromVecStringParam getSeqListDataFromVecStringParam; + getSeqListDataFromVecStringParam.dim = 3; + getSeqListDataFromVecStringParam.helper = this; + getSeqListDataFromVecStringParam.hashIndex = 0; + getSeqListDataFromVecStringParam.replaceIndex = 1; + getSeqListDataFromVecStringParam.type = CombatEffectType.CET_Buff_ReduceCD; + bool vecSequenceSumFromVecString = this.GetVecSequenceSumFromVecString(ref getSeqListDataFromVecStringParam, vecOut, new GetBuffDataSeqListString(this._GetBuffReduceSkillCDData), 3); + this.Merge(vecOut, 1); + return vecSequenceSumFromVecString; + } + + private ISeqListRef _GetBuffChangeSkillDamageData(BuffTable.RowData pBuffData) + { + return pBuffData.ChangeSkillDamage; + } + + public bool GetBuffChangeSkillDamage(SequenceList vecOut) + { + CombatEffectHelper.GetSeqListDataFromVecStringParam getSeqListDataFromVecStringParam; + getSeqListDataFromVecStringParam.dim = 2; + getSeqListDataFromVecStringParam.helper = this; + getSeqListDataFromVecStringParam.hashIndex = 0; + getSeqListDataFromVecStringParam.replaceIndex = 1; + getSeqListDataFromVecStringParam.type = CombatEffectType.CET_Buff_ChangeSkillDamage; + return this.GetVecSequenceSumFromVecString(ref getSeqListDataFromVecStringParam, vecOut, new GetBuffDataSeqListString(this._GetBuffChangeSkillDamageData), 2); + } + + public bool GetBuffChangeDamage(out double castDamage, out double receiveDamage) + { + castDamage = (double)this.GetSum(CombatEffectType.CET_Buff_ChangeDamage_Cast) * 0.001; + receiveDamage = (double)this.GetSum(CombatEffectType.CET_Buff_ChangeDamage_Receive) * 0.001; + return true; + } + + private ISeqListRef _GetBuffDOTData(BuffTable.RowData pBuffData) + { + return pBuffData.BuffDOT; + } + + private ISeqListRef _GetBuffDOTFromCasterData(BuffTable.RowData pBuffData) + { + return pBuffData.BuffDOTValueFromCaster; + } + + public bool GetBuffRegenerate(SequenceList vecDotOut, SequenceList vecFromCasterOut) + { + bool flag = true; + CombatEffectHelper.GetSeqListDataParam getSeqListDataParam; + getSeqListDataParam.dim = 3; + getSeqListDataParam.helper = this; + getSeqListDataParam.ratio = 0.001; + getSeqListDataParam.replaceIndex = 1; + getSeqListDataParam.type = CombatEffectType.CET_Buff_DOTorHOT; + flag = (flag && this.GetVecSequenceSum(ref getSeqListDataParam, vecDotOut, new GetBuffDataSeqListFloat(this._GetBuffDOTData), 3)); + CombatEffectHelper.GetSeqListDataParam getSeqListDataParam2; + getSeqListDataParam2.dim = 2; + getSeqListDataParam2.helper = this; + getSeqListDataParam2.ratio = 0.001; + getSeqListDataParam2.replaceIndex = 1; + getSeqListDataParam2.type = CombatEffectType.CET_Buff_DOTorHOT; + return flag && this.GetVecSequenceSum(ref getSeqListDataParam2, vecFromCasterOut, new GetBuffDataSeqListInt(this._GetBuffDOTFromCasterData), 2); + } + } +} -- cgit v1.1-26-g67d0