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 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); }
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 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); } } } }
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; }
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); }
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 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.GetSkillFuncParam(0x2c, 0, false); int num3 = _buffSkill.GetSkillFuncParam(0x2c, 1, false); int num4 = _buffSkill.GetSkillFuncParam(0x2c, 2, false); int num5 = _buffSkill.GetSkillFuncParam(0x2c, 3, false); 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); }
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 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); }
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); }
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 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 int OnTargetExtraHurt(BuffSkill _buffSkill, PoolObjHandle <ActorRoot> _attack) { int num = 0; ResDT_SkillFunc outSkillFunc = null; if ((_buffSkill != null) && _buffSkill.FindSkillFunc(0x30, out outSkillFunc)) { int typeMask = _buffSkill.GetSkillFuncParam(0x30, 0, false); int typeSubMask = _buffSkill.GetSkillFuncParam(0x30, 1, false); int num4 = _buffSkill.GetSkillFuncParam(0x30, 2, false); if (this.CheckTargetSubType(typeMask, typeSubMask, base.actorPtr)) { num = num4; } } return(num); }
private int OnTargetExtraHurt(BuffSkill _buffSkill, PoolObjHandle <ActorRoot> _attack) { int result = 0; ResDT_SkillFunc skillFunc = null; if (_buffSkill != null && _buffSkill.FindSkillFunc(48, out skillFunc)) { int skillFuncParam = _buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = _buffSkill.GetSkillFuncParam(skillFunc, 1, false); int skillFuncParam3 = _buffSkill.GetSkillFuncParam(skillFunc, 2, false); if (this.CheckTargetSubType(skillFuncParam, skillFuncParam2, this.actorPtr)) { result = skillFuncParam3; } } return(result); }
public void OnDamageExtraHurtFunc(ref HurtDataInfo _hurt, SkillSlotType _slotType) { 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(80, out skillFunc)) { SkillSlotType skillFuncParam = (SkillSlotType)buffSkill.GetSkillFuncParam(skillFunc, 0, false); if (_slotType == skillFuncParam) { int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); _hurt.iReduceDamage += skillFuncParam2; } } } }
public void OnDead(PoolObjHandle <ActorRoot> _attack) { BuffSkill inBuff = null; ResDT_SkillFunc outSkillFunc = null; if (this.clearRule != null) { this.clearRule.CheckBuffNoClear(RES_SKILLFUNC_CLEAR_RULE.RES_SKILLFUNC_CLEAR_DEAD); } if (this.logicEffect != null) { this.logicEffect.Clear(); } if (this.actorPtr.handle.ActorControl.IsKilledByHero()) { _attack = this.actorPtr.handle.ActorControl.LastHeroAtker; } for (int i = 0; i < this.SpawnedBuffList.Count; i++) { inBuff = this.SpawnedBuffList[i]; if ((inBuff != null) && inBuff.FindSkillFunc(0x20, out outSkillFunc)) { int reviveTime = inBuff.GetSkillFuncParam(0x20, 0, false); int reviveLife = inBuff.GetSkillFuncParam(0x20, 1, false); bool autoReset = inBuff.GetSkillFuncParam(0x20, 2, false) == 1; bool bBaseRevive = inBuff.GetSkillFuncParam(0x20, 3, false) == 0; bool bCDReset = inBuff.GetSkillFuncParam(0x20, 4, false) == 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); SkillUseParam inParam = new SkillUseParam(); inParam.SetOriginator(_attack); _attack.handle.SkillControl.SpawnBuff(_attack, ref inParam, inBuff.SkillID, true); } } this.OnDeadExtraEffect(_attack); this.markRule.Clear(); }
public void OnDead(PoolObjHandle <ActorRoot> _attack) { ResDT_SkillFunc skillFunc = null; if (this.clearRule != null) { this.clearRule.CheckBuffNoClear(2); } if (this.logicEffect != null) { this.logicEffect.Clear(); } if (this.actorPtr.get_handle().ActorControl.IsKilledByHero()) { _attack = this.actorPtr.get_handle().ActorControl.LastHeroAtker; } for (int i = 0; i < this.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = this.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.FindSkillFunc(32, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); bool autoReset = buffSkill.GetSkillFuncParam(skillFunc, 2, false) == 1; bool bBaseRevive = buffSkill.GetSkillFuncParam(skillFunc, 3, false) == 0; bool bCDReset = buffSkill.GetSkillFuncParam(skillFunc, 4, false) == 1; this.actor.ActorControl.SetReviveContext(skillFuncParam, skillFuncParam2, autoReset, bBaseRevive, bCDReset); this.RemoveBuff(buffSkill); } if (this.actor.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero && _attack && _attack.get_handle().TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero && buffSkill != null && buffSkill.cfgData != null && buffSkill.cfgData.bIsInheritByKiller == 1) { this.RemoveBuff(buffSkill); SkillUseParam skillUseParam = default(SkillUseParam); skillUseParam.SetOriginator(_attack); skillUseParam.bExposing = buffSkill.skillContext.bExposing; _attack.get_handle().SkillControl.SpawnBuff(_attack, ref skillUseParam, buffSkill.SkillID, true); } } this.OnDeadExtraEffect(_attack); this.markRule.Clear(); }
private bool OnChangeExtraEffectSkillSlot(PoolObjHandle <ActorRoot> _attack, SkillSlotType _slotType, out SkillSlotType _outSlotType) { ResDT_SkillFunc skillFunc = null; _outSlotType = _slotType; 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(78, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); if (_slotType == (SkillSlotType)skillFuncParam) { _outSlotType = (SkillSlotType)skillFuncParam2; return(true); } } } return(false); }
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.GetSkillFuncParam(0x21, 0, false); int num3 = inBuff.GetSkillFuncParam(0x21, 1, false); int num4 = inBuff.GetSkillFuncParam(0x21, 2, false); int typeMask = inBuff.GetSkillFuncParam(0x21, 3, false); int typeSubMask = inBuff.GetSkillFuncParam(0x21, 4, false); int num7 = inBuff.GetSkillFuncParam(0x21, 5, false); if ((num4 == 0) && this.CheckTargetSubType(typeMask, typeSubMask, base.actorPtr)) { 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) { SkillUseParam inParam = new SkillUseParam(); inParam.SetOriginator(_attack); _attack.handle.SkillControl.SpawnBuff(base.actorPtr, ref inParam, inSkillCombineId, true); inBuff.controlTime = Singleton <FrameSynchr> .GetInstance().LogicFrameTick; if (num7 == -1) { _attack.handle.BuffHolderComp.RemoveBuff(inBuff); } } } } } } }
public void OnAssistEffect(ref PoolObjHandle <ActorRoot> deadActor) { BuffSkill skill = null; ResDT_SkillFunc outSkillFunc = null; for (int i = 0; i < this.SpawnedBuffList.Count; i++) { skill = this.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 == 2) && this.CheckTargetSubType(typeMask, typeSubMask, deadActor)) { SkillUseParam inParam = new SkillUseParam(); inParam.SetOriginator(base.actorPtr); base.actor.SkillControl.SpawnBuff(base.actorPtr, ref inParam, inSkillCombineId, true); } } } }
private int OnControlExtraHurt(BuffSkill _buffSkill, PoolObjHandle <ActorRoot> _attack) { ResDT_SkillFunc outSkillFunc = null; if (((_buffSkill != null) && _buffSkill.FindSkillFunc(0x33, out outSkillFunc)) && (base.actor != null)) { BuffSkill skill = null; for (int i = 0; i < base.actor.BuffHolderComp.SpawnedBuffList.Count; i++) { skill = base.actor.BuffHolderComp.SpawnedBuffList[i]; if ((skill != null) && (skill.cfgData.dwEffectType == 2)) { return(_buffSkill.GetSkillFuncParam(0x33, 0, false)); } } } return(0); }
private int OnControlExtraHurt(BuffSkill _buffSkill, PoolObjHandle <ActorRoot> _attack) { int result = 0; ResDT_SkillFunc skillFunc = null; if (_buffSkill != null && _buffSkill.FindSkillFunc(51, out skillFunc) && this.actor != null) { for (int i = 0; i < this.actor.BuffHolderComp.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = this.actor.BuffHolderComp.SpawnedBuffList.get_Item(i); if (buffSkill != null && buffSkill.cfgData.bEffectType == 2) { result = _buffSkill.GetSkillFuncParam(skillFunc, 0, false); break; } } } return(result); }
public void OnDamageExtraValueEffect(ref HurtDataInfo _hurt, PoolObjHandle <ActorRoot> _attack, SkillSlotType _slotType) { 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 (_hurt.hurtType == HurtTypeDef.Therapic) { if ((skill != null) && skill.FindSkillFunc(0x40, out outSkillFunc)) { int num2 = skill.GetSkillFuncParam(0x40, 0, false); int num3 = skill.GetSkillFuncParam(0x40, 1, false); _hurt.iAddTotalHurtType = num2; _hurt.iAddTotalHurtValue = num3; } } else { if ((((_slotType == SkillSlotType.SLOT_SKILL_0) && (_attack.handle.SkillControl != null)) && (_attack.handle.SkillControl.bIsLastAtkUseSkill && (skill != null))) && skill.FindSkillFunc(0x3d, out outSkillFunc)) { int num4 = skill.GetSkillFuncParam(0x3d, 0, false); int num5 = skill.GetSkillFuncParam(0x3d, 1, false); int num6 = skill.GetSkillFuncParam(0x3d, 2, false); int num7 = skill.GetSkillFuncParam(0x3d, 3, false); if (num4 == 1) { num5 = (num5 * _hurt.hurtValue) / 0x2710; _hurt.hurtValue += num5; _hurt.adValue += num6; _hurt.apValue += num7; } else { _hurt.hurtValue += num5; _hurt.attackInfo.iActorATT += num6; _hurt.attackInfo.iActorINT += num7; } } if (((_hurt.target != 0) && (_hurt.target.handle.TheActorMeta.ActorType != ActorTypeDef.Actor_Type_Organ)) && ((skill != null) && skill.FindSkillFunc(0x44, out outSkillFunc))) { int num8 = skill.GetSkillFuncParam(0x44, 0, false); int num9 = skill.GetSkillFuncParam(0x44, 4, false); int num10 = skill.GetSkillFuncParam(0x44, 5, false); if (_hurt.target.handle.ValueComponent != null) { if (num8 == 1) { num9 = (_hurt.target.handle.ValueComponent.actorHpTotal * num9) / 0x2710; } if (((_hurt.target.handle.ValueComponent.actorHp <= num9) && (_hurt.target.handle.ActorControl != null)) && ((Singleton <FrameSynchr> .instance.LogicFrameTick - _hurt.target.handle.ActorControl.lastExtraHurtByLowHpBuffTime) >= num10)) { _hurt.target.handle.ActorControl.lastExtraHurtByLowHpBuffTime = Singleton <FrameSynchr> .instance.LogicFrameTick; int num11 = skill.GetSkillFuncParam(0x44, 1, false); int num12 = skill.GetSkillFuncParam(0x44, 2, false); int num13 = skill.GetSkillFuncParam(0x44, 3, false); if (num8 == 1) { num11 = (num11 * _hurt.hurtValue) / 0x2710; num12 = (num12 * _hurt.adValue) / 0x2710; num13 = (num13 * _hurt.apValue) / 0x2710; } _hurt.hurtValue += num11; _hurt.adValue += num12; _hurt.apValue += num13; } } } } } } }
public void OnDamageExtraValueEffect(ref HurtDataInfo _hurt, PoolObjHandle <ActorRoot> _attack, SkillSlotType _slotType) { ResDT_SkillFunc skillFunc = null; if (!_attack) { return; } for (int i = 0; i < _attack.get_handle().BuffHolderComp.SpawnedBuffList.get_Count(); i++) { BuffSkill buffSkill = _attack.get_handle().BuffHolderComp.SpawnedBuffList.get_Item(i); if (_hurt.hurtType == HurtTypeDef.Therapic) { if (buffSkill != null && buffSkill.FindSkillFunc(64, out skillFunc)) { _hurt.iAddTotalHurtValueRate = _attack.get_handle().ValueComponent.mActorValue[36].addRatio; _hurt.iAddTotalHurtValue = _attack.get_handle().ValueComponent.mActorValue[36].addValue; } } else { if (_slotType == SkillSlotType.SLOT_SKILL_0 && _attack.get_handle().SkillControl != null && _attack.get_handle().SkillControl.bIsLastAtkUseSkill&& buffSkill != null && buffSkill.FindSkillFunc(61, out skillFunc)) { int skillFuncParam = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int num = buffSkill.GetSkillFuncParam(skillFunc, 1, false); int skillFuncParam2 = buffSkill.GetSkillFuncParam(skillFunc, 2, false); int skillFuncParam3 = buffSkill.GetSkillFuncParam(skillFunc, 3, false); if (skillFuncParam == 1) { num = num * _hurt.hurtValue / 10000; _hurt.hurtValue += num; _hurt.adValue += skillFuncParam2; _hurt.apValue += skillFuncParam3; } else { _hurt.hurtValue += num; _hurt.attackInfo.iActorATT = _hurt.attackInfo.iActorATT + skillFuncParam2; _hurt.attackInfo.iActorINT = _hurt.attackInfo.iActorINT + skillFuncParam3; } } if (_hurt.target && _hurt.target.get_handle().TheActorMeta.ActorType != ActorTypeDef.Actor_Type_Organ && buffSkill != null && buffSkill.FindSkillFunc(68, out skillFunc)) { int skillFuncParam4 = buffSkill.GetSkillFuncParam(skillFunc, 0, false); int num2 = buffSkill.GetSkillFuncParam(skillFunc, 4, false); int skillFuncParam5 = buffSkill.GetSkillFuncParam(skillFunc, 5, false); if (_hurt.target.get_handle().ValueComponent != null) { if (skillFuncParam4 == 1) { num2 = _hurt.target.get_handle().ValueComponent.actorHpTotal *num2 / 10000; } if (_hurt.target.get_handle().ValueComponent.actorHp <= num2 && _hurt.target.get_handle().ActorControl != null && Singleton <FrameSynchr> .get_instance().LogicFrameTick - _hurt.target.get_handle().ActorControl.lastExtraHurtByLowHpBuffTime >= (ulong)((long)skillFuncParam5)) { _hurt.target.get_handle().ActorControl.lastExtraHurtByLowHpBuffTime = Singleton <FrameSynchr> .get_instance().LogicFrameTick; int num3 = buffSkill.GetSkillFuncParam(skillFunc, 1, false); int num4 = buffSkill.GetSkillFuncParam(skillFunc, 2, false); int num5 = buffSkill.GetSkillFuncParam(skillFunc, 3, false); if (skillFuncParam4 == 1) { num3 = num3 * _hurt.hurtValue / 10000; num4 = num4 * _hurt.adValue / 10000; num5 = num5 * _hurt.apValue / 10000; } _hurt.hurtValue += num3; _hurt.adValue += num4; _hurt.apValue += num5; } } } } } }
private void OnDamageExtraEffect(PoolObjHandle <ActorRoot> _attack, SkillSlotType _slotType) { ResDT_SkillFunc skillFunc = null; if (!_attack) { return; } 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)) { bool flag = false; bool flag2 = true; 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); int skillFuncParam6 = buffSkill.GetSkillFuncParam(skillFunc, 5, false); int skillFuncParam7 = buffSkill.GetSkillFuncParam(skillFunc, 6, false); int skillFuncParam8 = buffSkill.GetSkillFuncParam(skillFunc, 7, false); if (skillFuncParam3 == 0 && this.CheckTargetSubType(skillFuncParam4, skillFuncParam5, this.actorPtr)) { if (skillFuncParam7 == 0 || this.CheckTriggerCondtion(skillFuncParam7, skillFuncParam8, _attack, this.actorPtr)) { if (skillFuncParam2 == 0) { flag = true; } else if ((skillFuncParam2 & 1 << (int)_slotType) > 0) { flag = true; } if (skillFuncParam6 > 0) { flag2 = (Singleton <FrameSynchr> .GetInstance().LogicFrameTick - buffSkill.controlTime >= (ulong)((long)skillFuncParam6)); } if (flag && flag2) { if (skillFuncParam6 != -2 || !buffSkill.IsNextDestroy()) { SkillUseParam skillUseParam = default(SkillUseParam); skillUseParam.Init(); skillUseParam.SetOriginator(_attack); skillUseParam.bExposing = buffSkill.skillContext.bExposing; if (buffSkill.skillContext != null) { if (buffSkill.skillContext.SlotType != SkillSlotType.SLOT_SKILL_COUNT) { skillUseParam.SlotType = _slotType; } else { skillUseParam.SlotType = buffSkill.skillContext.SlotType; } } else { skillUseParam.SlotType = _slotType; } _attack.get_handle().SkillControl.SpawnBuff(this.actorPtr, ref skillUseParam, skillFuncParam, true); buffSkill.controlTime = Singleton <FrameSynchr> .GetInstance().LogicFrameTick; if (skillFuncParam6 == -1 || skillFuncParam6 == -2) { _attack.get_handle().BuffHolderComp.RemoveBuff(buffSkill); } } } } } } } }