public void OnAssistEffect(ref PoolObjHandle <ActorRoot> deadActor) { ResDT_SkillFunc skillFunc = null; for (int i = 0; i < this.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = this.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(33, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(skillFunc, 2, false); int skillFuncParam4 = buffSkill.GetSkillFuncParam(skillFunc, 3, false); int skillFuncParam5 = buffSkill.GetSkillFuncParam(skillFunc, 4, false); if (skillFuncParam3 == 2 && this.CheckTargetSubType(skillFuncParam4, skillFuncParam5, deadActor)) { SkillUseParam skillUseParam = default(SkillUseParam); skillUseParam.Init(); skillUseParam.SetOriginator(this.actorPtr); skillUseParam.bExposing = buffSkill.skillContext.bExposing; this.actor.SkillControl.SpawnBuff(this.actorPtr, ref skillUseParam, skillFuncParam, true); } } } }
public int GetSoulExpAddRate(PoolObjHandle <ActorRoot> _target) { int num = 0; BuffSkill skill = null; ResDT_SkillFunc outSkillFunc = null; if (_target != 0) { for (int i = 0; i < this.SpawnedBuffList.Count; i++) { skill = this.SpawnedBuffList[i]; if ((skill != null) && skill.FindSkillFunc(0x31, out outSkillFunc)) { int typeMask = skill.GetSkillFuncParam(0x31, 0, false); int typeSubMask = skill.GetSkillFuncParam(0x31, 1, false); int num5 = skill.GetSkillFuncParam(0x31, 2, false); int num6 = skill.GetSkillFuncParam(0x31, 3, false); if (this.CheckTargetSubType(typeMask, typeSubMask, _target)) { bool flag = true; if (num6 > 0) { flag = this.CheckTargetFromEnemy(base.actorPtr, _target); } if (flag) { num += num5; } } } } } return(num); }
private int OnConditionExtraHurt(BuffSkill _buffSkill, PoolObjHandle <ActorRoot> _attack) { int result = 0; ResDT_SkillFunc skillFunc = null; if (_buffSkill != null && _buffSkill.FindSkillFunc(44, out skillFunc)) { int skillFuncParam = _buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = _buffSkill.GetSkillFuncParam(skillFunc, 1, false); int skillFuncParam3 = _buffSkill.GetSkillFuncParam(skillFunc, 2, false); int skillFuncParam4 = _buffSkill.GetSkillFuncParam(skillFunc, 3, false); bool flag = skillFuncParam == 1; int num = (!flag) ? this.actor.ValueComponent.actorHp : _attack.get_handle().ValueComponent.actorHp; int num2 = (!flag) ? this.actor.ValueComponent.mActorValue[5].totalValue : _attack.get_handle().ValueComponent.mActorValue[5].totalValue; int num3 = num * 10000 / num2; if (skillFuncParam3 == 1) { if (num3 <= skillFuncParam2) { result = skillFuncParam4; } } else if (skillFuncParam3 == 4 && num3 >= skillFuncParam2) { result = skillFuncParam4; } } return(result); }
public static int OnDamageExtraEffect(ref HurtDataInfo _hurt, int _hurtValue) { SkillSlot skillSlot = null; if (!_hurt.atker || _hurt.atker.handle.ActorControl.IsDeadState) { return(_hurtValue); } BufferLogicEffect logicEffect = _hurt.atker.handle.BuffHolderComp.logicEffect; List <PoolObjHandle <BuffSkill> > list = logicEffect.GetExtraHurtList(); for (int i = 0; i < list.get_Count(); i++) { if (!_hurt.target) { return(_hurtValue); } BuffSkill buffSkill = list.get_Item(i); int skillFuncParam = buffSkill.GetSkillFuncParam(72, 0, false); if (_hurt.atkSlot == (SkillSlotType)skillFuncParam && _hurt.atker.handle.SkillControl.TryGetSkillSlot(_hurt.atkSlot, out skillSlot)) { int skillFuncParam2 = buffSkill.GetSkillFuncParam(72, 1, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(72, 2, false); int skillFuncParam4 = buffSkill.GetSkillFuncParam(72, 3, false); int skillFuncParam5 = buffSkill.GetSkillFuncParam(72, 4, false); logicEffect.SetSkillSlotUseTime(_hurt.atkSlot, skillFuncParam5); logicEffect.SetSkillSlotUseCount(_hurt.atkSlot, skillSlot.GetSkillUseCount()); return(logicEffect.DamageExtraEffect(ref _hurt, _hurtValue, skillFuncParam2, skillFuncParam3, skillFuncParam4)); } } return(_hurtValue); }
public void ClearBuff() { this.bRemoveList = false; for (int i = 0; i < this.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = this.SpawnedBuffList.get_Item(i); if (buffSkill != null) { buffSkill.Stop(); } } if (this.protectRule != null) { this.protectRule.ClearBuff(); } if (this.logicEffect != null) { this.logicEffect.ClearBuff(); } for (int j = 0; j < this.SpawnedBuffList.get_Count(); j++) { BuffSkill buffSkill = this.SpawnedBuffList.get_Item(j); if (buffSkill != null) { buffSkill.Release(); } } this.SpawnedBuffList.Clear(); this.delBuffList.Clear(); this.bRemoveList = true; }
public int GetCoinAddRate(PoolObjHandle <ActorRoot> _target) { int num = 0; ResDT_SkillFunc skillFunc = null; if (!_target) { return(num); } for (int i = 0; i < this.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = this.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(71, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(skillFunc, 2, false); int skillFuncParam4 = buffSkill.GetSkillFuncParam(skillFunc, 3, false); if (this.CheckTargetSubType(skillFuncParam, skillFuncParam2, _target)) { bool flag = true; if (skillFuncParam4 > 0) { flag = this.CheckTargetFromEnemy(this.actorPtr, _target); } if (flag) { num += skillFuncParam3; } } } } return(num); }
public void CacheClearBuff(BuffSkill _buff, RES_SKILLFUNC_CLEAR_RULE _rule) { if ((_buff.cfgData.dwClearRule == ((long)_rule)) && (_buff.cfgData.dwEffectType == 3)) { this.CacheBufferList.Add(_buff.cfgData.iCfgID); } }
private bool CheckTargetNoDamage(ref HurtDataInfo _hurt, BuffSkill _buffSkill) { int skillFuncParam = _buffSkill.GetSkillFuncParam(30, 1, false); int skillFuncParam2 = _buffSkill.GetSkillFuncParam(30, 2, false); if (skillFuncParam == 0) { return(true); } if (_hurt.atker) { int actorType = (int)_hurt.atker.get_handle().TheActorMeta.ActorType; if ((skillFuncParam & 1 << actorType) > 0) { if (actorType != 1) { return(true); } if (skillFuncParam2 == 0) { return(true); } int actorSubType = (int)_hurt.atker.get_handle().ActorControl.GetActorSubType(); if (actorSubType == skillFuncParam2) { return(true); } } } return(false); }
private bool CheckTargetNoDamage(ref HurtDataInfo _hurt, BuffSkill _buffSkill) { int num = _buffSkill.CustomParams[3]; int num2 = _buffSkill.CustomParams[4]; if (num == 0) { return(true); } if (_hurt.atker != 0) { int actorType = (int)_hurt.atker.handle.TheActorMeta.ActorType; if ((num & (((int)1) << actorType)) > 0) { if (actorType != 1) { return(true); } if (num2 == 0) { return(true); } if (_hurt.atker.handle.ActorControl.GetActorSubType() == num2) { return(true); } } } return(false); }
public void CacheClearBuff(BuffSkill _buff, RES_SKILLFUNC_CLEAR_RULE _rule) { if (_buff.cfgData.bClearRule == (byte)_rule && _buff.cfgData.bEffectType == 3) { this.CacheBufferList.Add(_buff.cfgData.iCfgID); } }
private bool NoDamageImpl(ref HurtDataInfo _hurt) { for (int i = 0; i < this.NoHurtBuffList.get_Count(); i++) { BuffSkill buffSkill = this.NoHurtBuffList.get_Item(i); if (buffSkill != null) { if (buffSkill.cfgData.bEffectSubType == 6) { if (this.CheckTargetNoDamage(ref _hurt, buffSkill)) { return(true); } } else if (_hurt.hurtType == HurtTypeDef.PhysHurt) { if (buffSkill.cfgData.bEffectSubType == 4 && this.CheckTargetNoDamage(ref _hurt, buffSkill)) { return(true); } } else if (_hurt.hurtType == HurtTypeDef.MagicHurt && buffSkill.cfgData.bEffectSubType == 5 && this.CheckTargetNoDamage(ref _hurt, buffSkill)) { return(true); } } } return(false); }
private bool NoDamageImpl(ref HurtDataInfo _hurt) { BuffSkill skill = null; for (int i = 0; i < this.NoHurtBuffList.Count; i++) { skill = this.NoHurtBuffList[i]; if (skill != null) { if (skill.cfgData.dwEffectSubType == 6) { if (this.CheckTargetNoDamage(ref _hurt, skill)) { return(true); } } else if (_hurt.hurtType == HurtTypeDef.PhysHurt) { if ((skill.cfgData.dwEffectSubType == 4) && this.CheckTargetNoDamage(ref _hurt, skill)) { return(true); } } else if (((_hurt.hurtType == HurtTypeDef.MagicHurt) && (skill.cfgData.dwEffectSubType == 5)) && this.CheckTargetNoDamage(ref _hurt, skill)) { return(true); } } } return(false); }
public bool CheckOverlay(BuffSkill _buffSkill) { if (_buffSkill.cfgData == null) { return(false); } if (!this.CheckTriggerRate(_buffSkill)) { return(false); } if (!this.CheckMutexCondition(_buffSkill)) { return(false); } if (!this.CheckDependCondition(_buffSkill)) { return(false); } if (_buffSkill.cfgData.dwOverlayMax < 1) { _buffSkill.SetOverlayCount(1); return(true); } BuffSkill skill = this.buffHolder.FindBuff(_buffSkill.SkillID); if ((skill != null) && (skill.GetOverlayCount() >= _buffSkill.cfgData.dwOverlayMax)) { if (_buffSkill.cfgData.dwOverlayRule != 1) { if (_buffSkill.cfgData.dwOverlayRule == 2) { this.buffHolder.RemoveBuff(_buffSkill.SkillID); return(false); } if (_buffSkill.cfgData.dwOverlayRule == 3) { this.buffHolder.RemoveBuff(_buffSkill.SkillID); _buffSkill.SetOverlayCount(1); return(true); } if (_buffSkill.cfgData.dwOverlayRule == 4) { int overlayCount = skill.GetOverlayCount(); this.buffHolder.RemoveBuff(_buffSkill.SkillID); _buffSkill.SetOverlayCount(overlayCount); return(true); } } return(false); } int num2 = 0; if (skill != null) { num2 = skill.GetOverlayCount(); this.buffHolder.RemoveBuff(_buffSkill.SkillID); } _buffSkill.SetOverlayCount(++num2); return(true); }
private void OnDeadExtraEffect(PoolObjHandle <ActorRoot> _attack) { if (_attack != 0) { BuffSkill skill = null; ResDT_SkillFunc outSkillFunc = null; for (int i = 0; i < _attack.handle.BuffHolderComp.SpawnedBuffList.Count; i++) { skill = _attack.handle.BuffHolderComp.SpawnedBuffList[i]; if ((skill != null) && skill.FindSkillFunc(0x21, out outSkillFunc)) { int inSkillCombineId = skill.GetSkillFuncParam(0x21, 0, false); int num3 = skill.GetSkillFuncParam(0x21, 1, false); int num4 = skill.GetSkillFuncParam(0x21, 2, false); int typeMask = skill.GetSkillFuncParam(0x21, 3, false); int typeSubMask = skill.GetSkillFuncParam(0x21, 4, false); if ((num4 == 1) && this.CheckTargetSubType(typeMask, typeSubMask, base.actorPtr)) { SkillUseParam inParam = new SkillUseParam(); inParam.SetOriginator(_attack); _attack.handle.SkillControl.SpawnBuff(_attack, ref inParam, inSkillCombineId, true); } } } } }
private void OnDamageTriggerEffect(PoolObjHandle <ActorRoot> _selfActor, PoolObjHandle <ActorRoot> _attacker) { ResDT_SkillFunc skillFunc = null; if (!_selfActor || !_attacker || _attacker.get_handle().TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Organ) { return; } for (int i = 0; i < _selfActor.get_handle().BuffHolderComp.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = _selfActor.get_handle().BuffHolderComp.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(84, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); if (skillFuncParam > 0) { SkillUseParam skillUseParam = default(SkillUseParam); skillUseParam.Init(); skillUseParam.SetOriginator(_selfActor); skillUseParam.bExposing = buffSkill.skillContext.bExposing; _selfActor.get_handle().SkillControl.SpawnBuff(_attacker, ref skillUseParam, skillFuncParam, true); _selfActor.get_handle().BuffHolderComp.RemoveBuff(buffSkill); } } } }
private void OnDeadExtraEffect(PoolObjHandle <ActorRoot> _attack) { if (!_attack) { return; } ResDT_SkillFunc skillFunc = null; for (int i = 0; i < _attack.get_handle().BuffHolderComp.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = _attack.get_handle().BuffHolderComp.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(33, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(skillFunc, 2, false); int skillFuncParam4 = buffSkill.GetSkillFuncParam(skillFunc, 3, false); int skillFuncParam5 = buffSkill.GetSkillFuncParam(skillFunc, 4, false); if (skillFuncParam3 == 1 && this.CheckTargetSubType(skillFuncParam4, skillFuncParam5, this.actorPtr)) { SkillUseParam skillUseParam = default(SkillUseParam); skillUseParam.Init(); skillUseParam.SetOriginator(_attack); skillUseParam.bExposing = buffSkill.skillContext.bExposing; _attack.get_handle().SkillControl.SpawnBuff(_attack, ref skillUseParam, skillFuncParam, true); } } } }
private void OnDeadExtraEffect(PoolObjHandle <ActorRoot> _attack) { BuffSkill skill = null; ResDT_SkillFunc outSkillFunc = null; if (_attack != 0) { for (int i = 0; i < _attack.handle.BuffHolderComp.SpawnedBuffList.Count; i++) { skill = _attack.handle.BuffHolderComp.SpawnedBuffList[i]; if ((skill != null) && skill.FindSkillFunc(0x21, out outSkillFunc)) { int inSkillCombineId = skill.CustomParams[0]; int num3 = skill.CustomParams[1]; int num4 = skill.CustomParams[2]; int typeMask = skill.CustomParams[3]; int typeSubMask = skill.CustomParams[4]; if ((num4 != 0) && this.CheckTargetSubType(typeMask, typeSubMask)) { SkillUseContext inContext = new SkillUseContext(); inContext.SetOriginator(_attack); _attack.handle.SkillControl.SpawnBuff(_attack, inContext, inSkillCombineId, true); } } } } }
public static int OnDamageExtraEffect(ref HurtDataInfo _hurt, int _hurtValue) { BuffSkill skill = null; SkillSlot slot = null; BufferLogicEffect logicEffect = null; List<PoolObjHandle<BuffSkill>> extraHurtList = null; if ((_hurt.atker != 0) && !_hurt.atker.handle.ActorControl.IsDeadState) { logicEffect = _hurt.atker.handle.BuffHolderComp.logicEffect; extraHurtList = logicEffect.GetExtraHurtList(); for (int i = 0; i < extraHurtList.Count; i++) { if (_hurt.target == 0) { return _hurtValue; } skill = extraHurtList[i]; int num = skill.GetSkillFuncParam(0x48, 0, false); if ((_hurt.atkSlot == num) && _hurt.atker.handle.SkillControl.TryGetSkillSlot(_hurt.atkSlot, out slot)) { int num2 = skill.GetSkillFuncParam(0x48, 1, false); int num3 = skill.GetSkillFuncParam(0x48, 2, false); int num4 = skill.GetSkillFuncParam(0x48, 3, false); int num5 = skill.GetSkillFuncParam(0x48, 4, false); logicEffect.SetSkillSlotUseTime(_hurt.atkSlot, num5); logicEffect.SetSkillSlotUseCount(_hurt.atkSlot, slot.GetSkillUseCount()); return logicEffect.DamageExtraEffect(ref _hurt, _hurtValue, num2, num3, num4); } } } return _hurtValue; }
private int OnConditionExtraHurt(BuffSkill _buffSkill, PoolObjHandle <ActorRoot> _attack) { int num = 0; ResDT_SkillFunc outSkillFunc = null; if ((_buffSkill != null) && _buffSkill.FindSkillFunc(0x2c, out outSkillFunc)) { int num2 = _buffSkill.CustomParams[0]; int num3 = _buffSkill.CustomParams[1]; int num4 = _buffSkill.CustomParams[2]; int num5 = _buffSkill.CustomParams[3]; bool flag = num2 == 1; int num6 = !flag ? base.actor.ValueComponent.actorHp : _attack.handle.ValueComponent.actorHp; int num7 = !flag ? base.actor.ValueComponent.mActorValue[RES_FUNCEFT_TYPE.RES_FUNCEFT_MAXHP].totalValue : _attack.handle.ValueComponent.mActorValue[RES_FUNCEFT_TYPE.RES_FUNCEFT_MAXHP].totalValue; int num8 = (num6 * 0x2710) / num7; if (num4 == 1) { if (num8 <= num3) { num = num5; } return(num); } if ((num4 == 4) && (num8 >= num3)) { num = num5; } } return(num); }
public void OnDead(PoolObjHandle <ActorRoot> _attack) { if (this.clearRule != null) { this.clearRule.CheckBuffNoClear(RES_SKILLFUNC_CLEAR_RULE.RES_SKILLFUNC_CLEAR_DEAD); } BuffSkill inBuff = null; ResDT_SkillFunc outSkillFunc = null; for (int i = 0; i < this.SpawnedBuffList.Count; i++) { inBuff = this.SpawnedBuffList[i]; if ((inBuff != null) && inBuff.FindSkillFunc(0x20, out outSkillFunc)) { int reviveTime = inBuff.CustomParams[0]; int reviveLife = inBuff.CustomParams[1]; bool autoReset = inBuff.CustomParams[2] == 1; bool bBaseRevive = inBuff.CustomParams[3] == 0; bool bCDReset = inBuff.CustomParams[4] == 1; base.actor.ActorControl.SetReviveContext(reviveTime, reviveLife, autoReset, bBaseRevive, bCDReset); this.RemoveBuff(inBuff); } if ((((base.actor.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero) && (_attack != 0)) && ((_attack.handle.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero) && (inBuff != null))) && ((inBuff.cfgData != null) && (inBuff.cfgData.bIsInheritByKiller == 1))) { this.RemoveBuff(inBuff); SkillUseContext inContext = new SkillUseContext(); inContext.SetOriginator(_attack); _attack.handle.SkillControl.SpawnBuff(_attack, inContext, inBuff.SkillID, true); } } this.OnDeadExtraEffect(_attack); }
public int GetSoulExpAddRate(PoolObjHandle <ActorRoot> _target) { int num = 0; BuffSkill skill = null; ResDT_SkillFunc outSkillFunc = null; if (_target != 0) { for (int i = 0; i < this.SpawnedBuffList.Count; i++) { skill = this.SpawnedBuffList[i]; if ((skill != null) && skill.FindSkillFunc(0x31, out outSkillFunc)) { int typeMask = skill.CustomParams[0]; int typeSubMask = skill.CustomParams[1]; int num5 = skill.CustomParams[2]; if (this.CheckTargetSubType(typeMask, typeSubMask)) { num += num5; } } } } return(num); }
public int OnHurtBounceDamage(ref HurtDataInfo hurt, int hp) { if (hp <= 0) { return(hp); } if (!hurt.atker || hurt.bBounceHurt) { return(hp); } ResDT_SkillFunc skillFunc = null; int num = hp; for (int i = 0; i < this.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = this.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(83, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 2, false); if ((skillFuncParam & 1 << (int)hurt.atker.get_handle().TheActorMeta.ActorType) <= 0) { int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); int num2 = num * skillFuncParam2 / 10000; num -= num2; HurtDataInfo hurtDataInfo = default(HurtDataInfo); HurtAttackerInfo attackInfo = default(HurtAttackerInfo); attackInfo.Init(hurt.target, hurt.atker); hurtDataInfo.atker = hurt.target; hurtDataInfo.target = hurt.atker; hurtDataInfo.attackInfo = attackInfo; hurtDataInfo.atkSlot = SkillSlotType.SLOT_SKILL_VALID; hurtDataInfo.hurtType = (HurtTypeDef)skillFuncParam3; hurtDataInfo.extraHurtType = ExtraHurtTypeDef.ExtraHurt_Value; hurtDataInfo.hurtValue = num2; hurtDataInfo.adValue = 0; hurtDataInfo.apValue = 0; hurtDataInfo.hpValue = 0; hurtDataInfo.loseHpValue = 0; hurtDataInfo.iConditionType = 0; hurtDataInfo.iConditionParam = 0; hurtDataInfo.hurtCount = 0; hurtDataInfo.firstHemoFadeRate = 0; hurtDataInfo.followUpHemoFadeRate = 0; hurtDataInfo.iEffectCountInSingleTrigger = 0; hurtDataInfo.bExtraBuff = false; hurtDataInfo.gatherTime = 0; hurtDataInfo.bBounceHurt = true; hurtDataInfo.bLastHurt = false; hurtDataInfo.iAddTotalHurtValueRate = 0; hurtDataInfo.iAddTotalHurtValue = 0; hurtDataInfo.iEffectFadeRate = 10000; hurtDataInfo.iOverlayFadeRate = 10000; int num3 = hurt.atker.get_handle().HurtControl.TakeBouncesDamage(ref hurtDataInfo); } } } return(num); }
public void AddBuff(BuffSkill inBuff) { ResDT_SkillFunc outSkillFunc = null; if ((inBuff != null) && inBuff.FindSkillFunc(0x48, out outSkillFunc)) { this.extraHurtList.Add(new PoolObjHandle<BuffSkill>(inBuff)); } }
public void AddBuff(BuffSkill inBuff) { this.SpawnedBuffList.Add(inBuff); this.protectRule.AddBuff(inBuff); BuffChangeEventParam param = new BuffChangeEventParam(true, base.actorPtr, inBuff); Singleton <GameSkillEventSys> .GetInstance().SendEvent <BuffChangeEventParam>(GameSkillEventDef.Event_BuffChange, base.actorPtr, ref param, GameSkillEventChannel.Channel_HostCtrlActor); }
private void OnDamageExtraEffect(PoolObjHandle <ActorRoot> _attack, SkillSlotType _slotType) { BuffSkill inBuff = null; ResDT_SkillFunc outSkillFunc = null; if (_attack != 0) { for (int i = 0; i < _attack.handle.BuffHolderComp.SpawnedBuffList.Count; i++) { inBuff = _attack.handle.BuffHolderComp.SpawnedBuffList[i]; if ((inBuff != null) && inBuff.FindSkillFunc(0x21, out outSkillFunc)) { bool flag = false; bool flag2 = true; int inSkillCombineId = inBuff.CustomParams[0]; int num3 = inBuff.CustomParams[1]; int num4 = inBuff.CustomParams[2]; int typeMask = inBuff.CustomParams[3]; int typeSubMask = inBuff.CustomParams[4]; int num7 = inBuff.CustomParams[5]; if ((num4 == 0) && this.CheckTargetSubType(typeMask, typeSubMask)) { if (num3 == 0) { flag = true; } else if ((num3 & (((int)1) << _slotType)) > 0) { flag = true; } if (num7 > 0) { if ((Singleton <FrameSynchr> .GetInstance().LogicFrameTick - inBuff.controlTime) >= num7) { flag2 = true; } else { flag2 = false; } } if (flag && flag2) { SkillUseContext inContext = new SkillUseContext(); inContext.SetOriginator(_attack); _attack.handle.SkillControl.SpawnBuff(base.actorPtr, inContext, inSkillCombineId, true); inBuff.controlTime = Singleton <FrameSynchr> .GetInstance().LogicFrameTick; if (num7 == -1) { _attack.handle.BuffHolderComp.RemoveBuff(inBuff); } } } } } } }
public bool CheckTriggerRate(BuffSkill _buffSkill) { if (_buffSkill.cfgData.iTriggerRate > 0) { int num = (int)FrameRandom.Random(10000u); return(num < _buffSkill.cfgData.iTriggerRate); } return(true); }
private int ResistDeadDamage(ref HurtDataInfo _hurt, int _hurtValue) { ResDT_SkillFunc skillFunc = null; if (this.buffHolder == null || this.buffHolder.actor == null) { return(_hurtValue); } ActorRoot actor = this.buffHolder.actor; for (int i = 0; i < actor.BuffHolderComp.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = actor.BuffHolderComp.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(54, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); if (buffSkill.GetSkillFuncParam(skillFunc, 1, false) == 0) { if (actor.ValueComponent.actorHp <= _hurtValue) { SkillUseParam skillUseParam = default(SkillUseParam); skillUseParam.SetOriginator(_hurt.atker); skillUseParam.bExposing = buffSkill.skillContext.bExposing; actor.SkillControl.SpawnBuff(actor.SelfPtr, ref skillUseParam, skillFuncParam, true); this.buffHolder.RemoveBuff(buffSkill); DefaultGameEventParam defaultGameEventParam = new DefaultGameEventParam(this.buffHolder.actorPtr, _hurt.atker); Singleton <GameEventSys> .get_instance().SendEvent <DefaultGameEventParam>(GameEventDef.Event_ActorImmuneDeadHurt, ref defaultGameEventParam); _hurtValue = 0; } } else { SkillUseParam skillUseParam2 = default(SkillUseParam); skillUseParam2.SetOriginator(_hurt.atker); skillUseParam2.bExposing = buffSkill.skillContext.bExposing; actor.SkillControl.SpawnBuff(actor.SelfPtr, ref skillUseParam2, skillFuncParam, true); this.buffHolder.RemoveBuff(buffSkill); _hurtValue = 0; } } if (_hurt.atkSlot == SkillSlotType.SLOT_SKILL_0 && buffSkill != null && buffSkill.FindSkillFunc(67, out skillFunc) && _hurt.atker && _hurt.atker.get_handle().TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero) { int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(skillFunc, 4, false); if (skillFuncParam2 == 1) { _hurtValue = _hurtValue * (10000 - skillFuncParam3) / 10000; } else if (skillFuncParam2 == 0) { _hurtValue -= skillFuncParam3; } } } return(_hurtValue); }
private int ResistDeadDamage(ref HurtDataInfo _hurt, int _hurtValue) { BuffSkill inBuff = null; ResDT_SkillFunc outSkillFunc = null; if ((this.buffHolder != null) && (this.buffHolder.actor != null)) { ActorRoot actor = this.buffHolder.actor; for (int i = 0; i < actor.BuffHolderComp.SpawnedBuffList.Count; i++) { inBuff = actor.BuffHolderComp.SpawnedBuffList[i]; if ((inBuff != null) && inBuff.FindSkillFunc(0x36, out outSkillFunc)) { int inSkillCombineId = inBuff.GetSkillFuncParam(0x36, 0, false); if (inBuff.GetSkillFuncParam(0x36, 1, false) == 0) { if (actor.ValueComponent.actorHp <= _hurtValue) { SkillUseParam inParam = new SkillUseParam(); inParam.SetOriginator(_hurt.atker); actor.SkillControl.SpawnBuff(actor.SelfPtr, ref inParam, inSkillCombineId, true); this.buffHolder.RemoveBuff(inBuff); DefaultGameEventParam prm = new DefaultGameEventParam(this.buffHolder.actorPtr, _hurt.atker); Singleton <GameEventSys> .instance.SendEvent <DefaultGameEventParam>(GameEventDef.Event_ActorImmuneDeadHurt, ref prm); _hurtValue = 0; } } else { SkillUseParam param3 = new SkillUseParam(); param3.SetOriginator(_hurt.atker); actor.SkillControl.SpawnBuff(actor.SelfPtr, ref param3, inSkillCombineId, true); this.buffHolder.RemoveBuff(inBuff); _hurtValue = 0; } } if ((((_hurt.atkSlot == SkillSlotType.SLOT_SKILL_0) && (inBuff != null)) && (inBuff.FindSkillFunc(0x43, out outSkillFunc) && (_hurt.atker != 0))) && (_hurt.atker.handle.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero)) { int num4 = inBuff.GetSkillFuncParam(0x43, 0, false); int num5 = inBuff.GetSkillFuncParam(0x43, 4, false); switch (num4) { case 1: _hurtValue = (_hurtValue * (0x2710 - num5)) / 0x2710; break; case 0: _hurtValue -= num5; break; } } } } return(_hurtValue); }
private int ResistDeadDamage(ref HurtDataInfo _hurt, int _hurtValue) { BuffSkill inBuff = null; ResDT_SkillFunc outSkillFunc = null; if ((this.buffHolder != null) && (this.buffHolder.actor != null)) { ActorRoot actor = this.buffHolder.actor; for (int i = 0; i < actor.BuffHolderComp.SpawnedBuffList.Count; i++) { inBuff = actor.BuffHolderComp.SpawnedBuffList[i]; if ((inBuff != null) && inBuff.FindSkillFunc(0x36, out outSkillFunc)) { int inSkillCombineId = inBuff.CustomParams[0]; if (inBuff.CustomParams[1] == 0) { if (actor.ValueComponent.actorHp <= _hurtValue) { SkillUseContext inContext = new SkillUseContext(); inContext.SetOriginator(_hurt.atker); actor.SkillControl.SpawnBuff(actor.SelfPtr, inContext, inSkillCombineId, true); this.buffHolder.RemoveBuff(inBuff); DefaultGameEventParam prm = new DefaultGameEventParam(this.buffHolder.actorPtr, _hurt.atker); Singleton <GameEventSys> .instance.SendEvent <DefaultGameEventParam>(GameEventDef.Event_ActorImmuneDeadHurt, ref prm); _hurtValue = 0; } } else { SkillUseContext context2 = new SkillUseContext(); context2.SetOriginator(_hurt.atker); actor.SkillControl.SpawnBuff(actor.SelfPtr, context2, inSkillCombineId, true); this.buffHolder.RemoveBuff(inBuff); _hurtValue = 0; } } if (((_hurt.atkSlot == SkillSlotType.SLOT_SKILL_0) && (inBuff != null)) && inBuff.FindSkillFunc(0x43, out outSkillFunc)) { int num4 = inBuff.CustomParams[0]; int num5 = inBuff.CustomParams[4]; switch (num4) { case 1: _hurtValue = (_hurtValue * (0x2710 - num5)) / 0x2710; break; case 0: _hurtValue -= num5; break; } } } } return(_hurtValue); }
public bool CheckDependCondition(BuffSkill _buffSkill) { if (_buffSkill.cfgData.iDependCfgID != 0) { if (this.buffHolder.FindBuff(_buffSkill.cfgData.iDependCfgID) == null) { return(false); } this.buffHolder.RemoveBuff(_buffSkill.cfgData.iDependCfgID); } return(true); }