private bool PostBeingHit(EvtBeingHit evt) { if (!base.actor.abilityPlugin.EvaluateAbilityPredicate(this.config.Predicates, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.sourceID), evt)) { return(false); } if (evt.attackData.rejected) { return(false); } float num = evt.attackData.damage * base.instancedAbility.Evaluate(this.config.DamagePercentage); this._attackProperty.AddedDamageValue = num; this._attackProperty.DamagePercentage = 0f; this._attackProperty.AniDamageRatio = 0f; this._attackProperty.FrameHalt = 0; this._attackProperty.HitType = AttackResult.ActorHitType.Ailment; this._attackProperty.HitEffect = AttackResult.AnimatorHitEffect.Normal; this._attackProperty.RetreatVelocity = 0f; this._attackProperty.IsAnimEventAttack = true; this._attackProperty.IsInComboCount = false; bool forceSkipAttackerResolve = !base.actor.IsActive(); AttackData attackData = DamageModelLogic.CreateAttackDataFromAttackProperty(base.actor, this._attackProperty, null, null); AttackPattern.SendHitEvent(base.actor.runtimeID, evt.sourceID, null, null, attackData, forceSkipAttackerResolve, MPEventDispatchMode.Normal); base.actor.abilityPlugin.HandleActionTargetDispatch(this.config.Actions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.sourceID), evt); return(true); }
private void OnUpdateAttackTarget(BaseMonoEntity entity) { if ((entity != null) && this._isTutorialAvailable) { MonsterActor attackee = Singleton <EventManager> .Instance.GetActor <MonsterActor>(entity.GetRuntimeID()); BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar(); AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(localAvatar.GetRuntimeID()); EntityNature attackerNature = (EntityNature)attackee.metaConfig.nature; EntityNature attribute = (EntityNature)actor.avatarDataItem.Attribute; float num = DamageModelLogic.GetNatureDamageBonusRatio(attackerNature, attribute, attackee); if (((((attackee != null) && (actor != null)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep))) && ((!this.IsAllStepDone() && (num > 1f)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep)))) && !this.IsAllStepDone()) { this.ActiveCurrentStep(); this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep0)); } if ((((attackee != null) && (actor != null)) && ((this._killAmount >= 2) && (this._monsterCreatedAmount > 2))) && (((num > 1f) && (base.step == 2)) && ((base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep) && !this.IsAllStepDone()))) { this.ActiveCurrentStep(); this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep2)); } } }
protected virtual void CreateBullet(HitExplodeTracingBulletMixinArgument arg, uint bulletRuntimeID, uint otherID) { string bulletTypeName = this.baseConfig.BulletTypeName; float speed = base.instancedAbility.Evaluate(this.baseConfig.BulletSpeed); if (arg != null) { if (arg.BulletName != null) { bulletTypeName = arg.BulletName; } if (arg.RandomBulletNames != null) { bulletTypeName = arg.RandomBulletNames[UnityEngine.Random.Range(0, arg.RandomBulletNames.Length)]; } if (arg.BulletSpeed != null) { speed = base.instancedAbility.Evaluate(arg.BulletSpeed); } } AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(bulletTypeName, base.actor, speed, this.baseConfig.Targetting, this.baseConfig.IgnoreTimeScale, bulletRuntimeID, base.instancedAbility.Evaluate(this.baseConfig.AliveDuration)); if ((this.baseConfig.BulletEffect != null) && (this.baseConfig.BulletEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.TriggerEntityEffectPattern(this.baseConfig.BulletEffect.EffectPattern, bullet.triggerBullet, this.baseConfig.BulletEffectGround); } this.InitBulletForward(bullet); this.InitBulletForwardWithArgument(bullet, arg, otherID); this._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, this.baseConfig.HitAnimEventID)); }
public void SetupNatureBonus() { BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar(); EntityNature attribute = (EntityNature)Singleton <EventManager> .Instance.GetActor <AvatarActor>(localAvatar.GetRuntimeID()).avatarDataItem.Attribute; EntityNature nature = (EntityNature)this._currentMonster.metaConfig.nature; int natureBonusType = DamageModelLogic.GetNatureBonusType(attribute, nature); base.transform.Find("DamageMark/Up").gameObject.SetActive(natureBonusType == 1); base.transform.Find("DamageMark/Down").gameObject.SetActive(natureBonusType == -1); }
private bool OnHittingOther(EvtHittingOther evt) { if (evt.attackData == null) { evt.attackData = DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(this, evt.animEventID); } if ((evt.hitCollision == null) && (Singleton <EventManager> .Instance.GetActor(evt.toID) != null)) { BaseMonoEntity victimEntity = Singleton <EventManager> .Instance.GetEntity(evt.toID); evt.hitCollision = this.CalcHitCollision(this.config.PropArguments.RetreatType, victimEntity); } evt.attackData.hitCollision = evt.hitCollision; return(true); }
public static void SendHitEvent(uint attackerID, uint beHitID, string attackName, AttackResult.HitCollsion hitCollision, AttackData attackData, bool forceSkipAttackerResolve = false, MPEventDispatchMode mode = 0) { if (forceSkipAttackerResolve || Singleton <LevelManager> .Instance.gameMode.ShouldAttackPatternSendBeingHit(beHitID)) { EvtBeingHit evt = new EvtBeingHit { targetID = beHitID, sourceID = attackerID, animEventID = attackName }; if (attackData != null) { if (attackData.hitCollision == null) { attackData.hitCollision = hitCollision; } evt.attackData = attackData; } else { evt.attackData = DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(Singleton <EventManager> .Instance.GetActor(attackerID), attackName); evt.attackData.resolveStep = AttackData.AttackDataStep.AttackerResolved; evt.attackData.hitCollision = hitCollision; } Singleton <EventManager> .Instance.FireEvent(evt, mode); } else { EvtHittingOther other = new EvtHittingOther { hitCollision = hitCollision, targetID = attackerID, toID = beHitID, animEventID = attackName }; if (attackData != null) { if (attackData.hitCollision == null) { attackData.hitCollision = hitCollision; } other.attackData = attackData; } else { other.hitCollision = hitCollision; } Singleton <EventManager> .Instance.FireEvent(other, mode); } }
public override void OnAbilityTriggered(EvtAbilityStart evt) { string bulletTypeName = this.config.BulletTypeName; int grenadeAmount = this.config.GrenadeAmount; string hitAnimEventID = this.config.HitAnimEventID; GrenadesMixinArgument abilityArgument = evt.abilityArgument as GrenadesMixinArgument; if (abilityArgument != null) { grenadeAmount = abilityArgument.BulletAmount; if (!string.IsNullOrEmpty(abilityArgument.HitAnimEventID)) { hitAnimEventID = abilityArgument.HitAnimEventID; } } for (int i = 0; i < grenadeAmount; i++) { AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(bulletTypeName, base.actor, base.instancedAbility.Evaluate(this.config.BulletSpeed), this.config.Targetting, this.config.IgnoreTimeScale, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), -1f); if ((this.config.BulletEffect != null) && (this.config.BulletEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.TriggerEntityEffectPattern(this.config.BulletEffect.EffectPattern, bullet.triggerBullet, this.config.BulletEffectGround); } BaseMonoEntity entity = null; Vector3 forward = base.entity.transform.forward; if (evt.otherID != 0) { BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.otherID); if ((actor != null) && (actor.entity != null)) { entity = actor.entity; } } if (entity != null) { bullet.triggerBullet.transform.position = entity.GetAttachPoint("RootNode").position; forward = entity.transform.forward; float angle = ((360 * i) / (this.config.GrenadeAmount + 1)) - 180; forward = (Vector3)(Quaternion.AngleAxis(angle, Vector3.up) * forward); } this.InitBulletDirAndPos(bullet, forward); base._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, hitAnimEventID)); } }
public override void OnAbilityTriggered(EvtAbilityStart evt) { BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar(); if (localAvatar != null) { int count = localAvatar.SubAttackTargetList.Count; for (int i = 0; i < count; i++) { string bulletTypeName = this.config.BulletTypeName; HitExplodeTracingBulletMixinArgument abilityArgument = evt.abilityArgument as HitExplodeTracingBulletMixinArgument; if (abilityArgument != null) { if (abilityArgument.BulletName != null) { bulletTypeName = abilityArgument.BulletName; } if (abilityArgument.RandomBulletNames != null) { bulletTypeName = abilityArgument.RandomBulletNames[UnityEngine.Random.Range(0, abilityArgument.RandomBulletNames.Length)]; } } AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(bulletTypeName, base.actor, base.instancedAbility.Evaluate(this.config.BulletPostionLinearSpeed), this.config.Targetting, this.config.IgnoreTimeScale, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), -1f); if ((this.config.BulletEffect != null) && (this.config.BulletEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.TriggerEntityEffectPattern(this.config.BulletEffect.EffectPattern, bullet.triggerBullet, this.config.BulletEffectGround); } base._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, this.config.HitAnimEventID)); float angle = (180 / (count + 1)) * (i + 1); float num4 = base.instancedAbility.Evaluate(this.config.BulletPositionRadius); float duration = base.instancedAbility.Evaluate(this.config.BulletPositionDuration); Vector3 vector = Vector3.Cross(Vector3.up, base.entity.transform.forward); vector = (Vector3)(Quaternion.AngleAxis(angle, base.entity.transform.forward) * vector); Vector3 vector2 = (Vector3)(vector.normalized * num4); Vector3 position = localAvatar.SubAttackTargetList[i].transform.position; Vector3 up = Vector3.up; position += up; bullet.triggerBullet.SetupPositioning(bullet.triggerBullet.transform.position, bullet.triggerBullet.transform.position + vector2, duration, base.instancedAbility.Evaluate(this.config.BulletSpeed), this.config.TracingLerpCoef, this.config.TracingLerpCoefAcc, position, this.config.PassBy); this.InitBulletForward(bullet); } } }
private BulletInfo CreateOneBullet() { AbilityTriggerBullet bullet = Singleton <DynamicObjectManager> .Instance.CreateAbilityLinearTriggerBullet(this._bulletName, base.actor, base.instancedAbility.Evaluate(this.config.BulletSpeed), this.config.Targetting, this.config.IgnoreTimeScale, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), -1f); Vector3 zero = Vector3.zero; this.InitBulletPosAndForward(bullet, out zero); BulletInfo info = new BulletInfo { bulletID = bullet.runtimeID, backTimer = this.config.BackTime, holdTimer = this.config.HoldTime, lifeTimer = this.config.LifeTime, startPosRelative = zero }; base._bulletAttackDatas.Add(bullet.runtimeID, DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(base.actor, this.config.HitAnimEventID)); bullet.triggerBullet.acceleration = this.config.Acceleration; bullet.triggerBullet.SetCollisionEnabled(false); return(info); }
private bool OnHittingOther(EvtHittingOther evt) { if (evt.attackData == null) { evt.attackData = DamageModelLogic.CreateAttackDataFromAttackerAnimEvent(this, evt.animEventID); } if ((evt.attackData.hitCollision == null) && (evt.hitCollision != null)) { evt.attackData.hitCollision = evt.hitCollision; } else if (((evt.hitCollision == null) && (evt.attackData.hitCollision == null)) && (Singleton <EventManager> .Instance.GetActor(evt.toID) != null)) { BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.toID); AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitPoint = entity.GetAttachPoint("RootNode").position, hitDir = entity.XZPosition - this.monster.XZPosition }; evt.hitCollision = collsion; } return(true); }
private bool OnPostBeingHit(EvtBeingHit evt) { if (!evt.attackData.isAnimEventAttack) { return(false); } if (evt.attackData.rejected) { return(false); } if (base.actor.abilityState.ContainsState(AbilityState.Invincible) || base.actor.abilityState.ContainsState(AbilityState.Undamagable)) { return(false); } if ((this._globalShieldValue == null) || (this._globalShieldValue.Value <= 0f)) { return(false); } float num = this._globalShieldValue.Value; float num2 = evt.attackData.damage * (1f - DamageModelLogic.GetDefenceRatio(base.instancedAbility.caster.defense * base.instancedAbility.Evaluate(this.config.ShieldDefenceRatio), evt.attackData.attackerLevel)); float newValue = num - num2; bool flag = Mathf.Approximately(evt.attackData.GetTotalDamage() - evt.attackData.damage, 0f); if (newValue <= 0f) { newValue = 0f; } this._globalShieldValue.Pub(newValue); if (newValue > 0f) { if (flag) { evt.attackData.Reject(AttackResult.RejectType.RejectAll); } else { evt.attackData.damage = 0f; evt.attackData.hitEffect = AttackResult.AnimatorHitEffect.Mute; } if (evt.attackData.hitCollision != null) { base.FireMixinEffect(this.config.ShieldSuccessEffect, base.entity, evt.attackData.hitCollision.hitPoint, evt.attackData.hitCollision.hitDir, false); } else { base.FireMixinEffect(this.config.ShieldSuccessEffect, base.entity, false); } base.actor.abilityPlugin.HandleActionTargetDispatch(this.config.ShieldSuccessActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.sourceID), evt); } else if (num > 0f) { float num4 = 1f - (num / evt.attackData.damage); evt.attackData.damage *= num4; if (this.config.ShieldBrokenTimeSlow > 0f) { Singleton <LevelManager> .Instance.levelActor.TimeSlow(this.config.ShieldBrokenTimeSlow); } base.FireMixinEffect(this.config.ShieldBrokenEffect, base.entity, false); base.actor.abilityPlugin.HandleActionTargetDispatch(this.config.ShieldBrokenActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.sourceID), evt); evt.attackData.frameHalt = 0; evt.attackData.attackerAniDamageRatio = 10f; Singleton <EventManager> .Instance.FireEvent(new EvtShieldBroken(base.actor.runtimeID), MPEventDispatchMode.Normal); evt.attackData.AddHitFlag(AttackResult.ActorHitFlag.Count); } return(true); }
private bool OnBeingHitResolve(EvtBeingHit evt) { evt.Resolve(); AttackResult attackResult = DamageModelLogic.ResolveAttackDataFinal(this, evt.attackData); if (attackResult.hitCollision == null) { AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitPoint = this.prop.RootNode.position, hitDir = -this.prop.transform.forward }; attackResult.hitCollision = collsion; } if (!evt.attackData.isAnimEventAttack) { return(false); } if (base.isAlive != 0) { float totalDamage = attackResult.GetTotalDamage(); float newValue = base.HP - totalDamage; if (newValue <= 0f) { newValue = 0f; } DelegateUtils.UpdateField(ref this.HP, newValue, newValue - base.HP, base.onHPChanged); if (base.HP == 0f) { if (base.abilityState.ContainsState(AbilityState.Limbo)) { this.BeingHit(attackResult, BeHitEffect.NormalBeHit, evt.sourceID); } else { this.BeingHit(attackResult, BeHitEffect.KillingBeHit, evt.sourceID); this.Kill(evt.sourceID, evt.animEventID); } } else { this.BeingHit(attackResult, BeHitEffect.NormalBeHit, evt.sourceID); } } if ((attackResult.attackEffectPattern != null) && ((attackResult.hitEffectPattern == AttackResult.HitEffectPattern.Normal) || (attackResult.hitEffectPattern == AttackResult.HitEffectPattern.OnlyAttack))) { AttackPattern.ActAttackEffects(attackResult.attackEffectPattern, this.prop, attackResult.hitCollision.hitPoint, attackResult.hitCollision.hitDir); } if ((attackResult.beHitEffectPattern != null) && ((attackResult.hitEffectPattern == AttackResult.HitEffectPattern.Normal) || (attackResult.hitEffectPattern == AttackResult.HitEffectPattern.OnlyBeHit))) { AttackPattern.ActAttackEffects(attackResult.beHitEffectPattern, this.prop, attackResult.hitCollision.hitPoint, attackResult.hitCollision.hitDir); } if (evt.attackData.isAnimEventAttack) { EvtAttackLanded landed = new EvtAttackLanded(evt.sourceID, base.runtimeID, evt.animEventID, attackResult); Singleton <EventManager> .Instance.FireEvent(landed, MPEventDispatchMode.Normal); Singleton <NotifyManager> .Instance.FireNotify(new Notify(NotifyTypes.AttackLanded, landed)); } else { Singleton <EventManager> .Instance.FireEvent(new EvtDamageLanded(evt.sourceID, base.runtimeID, attackResult), MPEventDispatchMode.Normal); } return(true); }
private bool OnBeingHit(EvtBeingHit evt) { DamageModelLogic.ResolveAttackDataByAttackee(this, evt.attackData); return(true); }
protected virtual bool OnBeingHitResolve(EvtBeingHit evt) { evt.Resolve(); if (evt.attackData.rejected) { if (evt.attackData.rejectState == AttackResult.RejectType.RejectButShowAttackEffect) { this.AmendHitCollision(evt.attackData); this.FireAttackDataEffects(evt.attackData); } return(false); } if ((base.isAlive == 0) || (evt.attackData.GetTotalDamage() > base.HP)) { evt.attackData.attackeeAniDefenceRatio = 0f; } AttackResult attackResult = DamageModelLogic.ResolveAttackDataFinal(this, evt.attackData); this.AmendHitCollision(attackResult); if (base.isAlive != 0) { if (base.abilityState.ContainsState(AbilityState.Invincible)) { attackResult.damage = 0f; attackResult.plainDamage = 0f; attackResult.fireDamage = 0f; attackResult.thunderDamage = 0f; attackResult.iceDamage = 0f; attackResult.alienDamage = 0f; attackResult.hitLevel = AttackResult.ActorHitLevel.Mute; attackResult.hitEffect = AttackResult.AnimatorHitEffect.Mute; attackResult.frameHalt += 5; } else if (base.abilityState.ContainsState(AbilityState.Endure)) { attackResult.hitEffect = AttackResult.AnimatorHitEffect.Mute; attackResult.frameHalt += 5; } if (!attackResult.isAnimEventAttack) { attackResult.hitEffect = AttackResult.AnimatorHitEffect.Mute; attackResult.hitLevel = AttackResult.ActorHitLevel.Normal; attackResult.hitEffectPattern = AttackResult.HitEffectPattern.OnlyBeHit; attackResult.attackCameraShake = null; attackResult.killEffect = KillEffect.KillNow; } float totalDamage = attackResult.GetTotalDamage(); float newValue = base.HP - totalDamage; if (newValue <= 0f) { newValue = 0f; } if (base.abilityState.ContainsState(AbilityState.Undamagable)) { DelegateUtils.UpdateField(ref this.HP, (float)base.HP, newValue - base.HP, base.onHPChanged); } else { DelegateUtils.UpdateField(ref this.HP, newValue, newValue - base.HP, base.onHPChanged); evt.resolvedDamage = totalDamage; } if (base.HP == 0f) { if ((base.abilityState & AbilityState.Limbo) != AbilityState.None) { evt.beHitEffect = BeHitEffect.NormalBeHit; this.BeingHit(attackResult, BeHitEffect.NormalBeHit); } else { if (attackResult.killEffect != KillEffect.KillTillHitAnimationEnd) { if ((this.monster.IsAnimatorInTag(MonsterData.MonsterTagGroup.Throw) || (evt.attackData.hitEffect == AttackResult.AnimatorHitEffect.ThrowUp)) || (evt.attackData.hitEffect == AttackResult.AnimatorHitEffect.ThrowUpBlow)) { attackResult.killEffect = KillEffect.KillFastWithNormalAnim; } else if (((base.abilityState & AbilityState.WitchTimeSlowed) != AbilityState.None) || (attackResult.aniDamageRatio >= 0.9f)) { attackResult.killEffect = KillEffect.KillFastWithDieAnim; } } this.Kill(evt.sourceID, evt.animEventID, attackResult.killEffect); evt.beHitEffect = BeHitEffect.KillingBeHit; this.BeingHit(attackResult, BeHitEffect.KillingBeHit); } } else { evt.beHitEffect = BeHitEffect.NormalBeHit; this.BeingHit(attackResult, BeHitEffect.NormalBeHit); } } else { evt.beHitEffect = BeHitEffect.OverkillBeHit; this.BeingHit(attackResult, BeHitEffect.OverkillBeHit); } this.FireAttackDataEffects(attackResult); if (evt.attackData.isAnimEventAttack) { EvtAttackLanded landed = new EvtAttackLanded(evt.sourceID, base.runtimeID, evt.animEventID, attackResult); Singleton <EventManager> .Instance.FireEvent(landed, MPEventDispatchMode.Normal); Singleton <NotifyManager> .Instance.FireNotify(new Notify(NotifyTypes.AttackLanded, landed)); } else { Singleton <EventManager> .Instance.FireEvent(new EvtDamageLanded(evt.sourceID, base.runtimeID, attackResult), MPEventDispatchMode.Normal); } base.MarkImportantEventIsHandled(evt); return(true); }
protected virtual bool OnBeingHit(EvtBeingHit evt) { DamageModelLogic.ResolveAttackDataByAttackee(this, evt.attackData); return(true); }
private bool ListenBeingHit(EvtBeingHit evt) { if (evt.attackData.rejected) { return(false); } if (this.isUpdating) { if (!evt.attackData.IsFinalResolved()) { return(false); } if (!evt.attackData.isAnimEventAttack) { return(false); } this.allDamage += evt.attackData.GetTotalDamage(); ushort num = Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.targetID); ushort num2 = Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.sourceID); switch (num) { case 3: { if (num2 == 4) { MonsterStastics monsterStastics = this.GetMonsterStastics(evt.sourceID); if (monsterStastics != null) { monsterStastics.damage += evt.attackData.GetTotalDamage(); monsterStastics.hitAvatarTimes = SafeInt32.op_Increment(monsterStastics.hitAvatarTimes); if (evt.attackData.hitEffect > AttackResult.AnimatorHitEffect.Light) { monsterStastics.breakAvatarTimes = SafeInt32.op_Increment(monsterStastics.breakAvatarTimes); } } } AvatarStastics avatarStastics = this.GetAvatarStastics(evt.targetID); if (avatarStastics == null) { return(true); } avatarStastics.avatarBeDamaged += evt.attackData.GetTotalDamage(); avatarStastics.avatarBeingHitTimes = SafeInt32.op_Increment(avatarStastics.avatarBeingHitTimes); if (evt.attackData.hitEffect > AttackResult.AnimatorHitEffect.Light) { avatarStastics.avatarBeingBreakTimes = SafeInt32.op_Increment(avatarStastics.avatarBeingBreakTimes); } this.monsterDamage += evt.attackData.GetTotalDamage(); this.avatarBeingHitTimes++; if (evt.attackData.attackerAniDamageRatio > evt.attackData.attackeeAniDefenceRatio) { this.avatarBeingHitTimes++; } if (evt.attackData.hitLevel == AttackResult.ActorHitLevel.Normal) { avatarStastics.behitNormalDamageMax = Mathf.Max(evt.attackData.GetTotalDamage(), (float)avatarStastics.behitNormalDamageMax); } else if (evt.attackData.hitLevel == AttackResult.ActorHitLevel.Critical) { avatarStastics.behitCriticalDamageMax = Mathf.Max(evt.attackData.GetTotalDamage(), (float)avatarStastics.behitCriticalDamageMax); } break; } case 4: { MonsterActor attackee = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID); if (num2 == 3) { AvatarStastics stastics3 = this.GetAvatarStastics(evt.sourceID); if (stastics3 == null) { return(true); } float a = DamageModelLogic.GetNatureDamageBonusRatio(evt.attackData.attackerNature, evt.attackData.attackeeNature, attackee); if (a > 1f) { stastics3.restrictionDamage += evt.attackData.GetTotalDamage(); } else if (a < 1f) { stastics3.beRestrictedDamage += evt.attackData.GetTotalDamage(); } else if (Mathf.Approximately(a, 1f)) { stastics3.normalDamage += evt.attackData.GetTotalDamage(); } if (evt.attackData.attackCategoryTag.ContainsTag(AttackResult.AttackCategoryTag.Weapon)) { stastics3.avatarActiveWeaponSkillDamage += evt.attackData.GetTotalDamage(); this.avatarWeaponDdamage += evt.attackData.GetTotalDamage(); } if (evt.attackData.hitEffect > AttackResult.AnimatorHitEffect.Light) { stastics3.avatarBreakTimes = SafeInt32.op_Increment(stastics3.avatarBreakTimes); } stastics3.avatarDamage += evt.attackData.GetTotalDamage(); stastics3.avatarHitTimes = SafeInt32.op_Increment(stastics3.avatarHitTimes); if (evt.attackData.isInComboCount) { stastics3.avatarEffectHitTimes = SafeInt32.op_Increment(stastics3.avatarEffectHitTimes); } if (evt.attackData.hitLevel == AttackResult.ActorHitLevel.Normal) { stastics3.hitNormalDamageMax = Mathf.Max(evt.attackData.GetTotalDamage(), (float)stastics3.hitNormalDamageMax); } else if (evt.attackData.hitLevel == AttackResult.ActorHitLevel.Critical) { stastics3.hitCriticalDamageMax = Mathf.Max(evt.attackData.GetTotalDamage(), (float)stastics3.hitCriticalDamageMax); } } this.avatarDamage += evt.attackData.GetTotalDamage(); if (evt.attackData.isInComboCount) { this.avatarEffectHitTimes++; } this.monstersBeingHitTimes++; if (evt.attackData.attackerAniDamageRatio > evt.attackData.attackeeAniDefenceRatio) { this.avatarBreakTimes++; } break; } } } return(true); }