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);
}
}
}
}
}
}
}
}
