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 KillBlackHole(bool doExplodeHit) { if ((this._fieldActor != null) && (this._fieldActor.triggerField != null)) { List <uint> insideRuntimeIDs = this._fieldActor.GetInsideRuntimeIDs(); this._fieldActor.triggerField.transform.position.y = 1f; for (int i = 0; i < insideRuntimeIDs.Count; i++) { uint runtimeID = insideRuntimeIDs[i]; BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(runtimeID); if (((actor != null) && (actor.gameObject != null)) && ((this.config.ModifierNames != null) && (this.config.ModifierNames.Length > 0))) { int index = 0; int length = this.config.ModifierNames.Length; while (index < length) { if (actor.abilityPlugin != null) { actor.abilityPlugin.TryRemoveModifier(base.instancedAbility, this.config.ModifierNames[index]); } index++; } } } if (doExplodeHit && (this.config.ExplodeAnimEventID != null)) { List <CollisionResult> list2 = CollisionDetectPattern.CylinderCollisionDetectBySphere(this._fieldActor.triggerField.XZPosition, this._fieldActor.triggerField.XZPosition, base.instancedAbility.Evaluate(this.config.Radius), 2f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, MixinTargetting.Enemy)); for (int j = 0; j < list2.Count; j++) { CollisionResult result = list2[j]; BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity); if (collisionResultEntity != null) { Singleton <EventManager> .Instance.FireEvent(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), this.config.ExplodeAnimEventID, result.hitPoint, result.hitForward), MPEventDispatchMode.Normal); } } } base.FireMixinEffect(this.config.DestroyEffect, this._fieldActor.triggerField, false); this._fieldActor.Kill(); this._blackHoleTimer.timespan = base.instancedAbility.Evaluate(this.config.Duration); this._blackHoleTimer.Reset(false); if ((this.config.CreationEffect != null) && (this.config.CreationEffect.EffectPattern != null)) { Singleton <EffectManager> .Instance.SetDestroyIndexedEffectPattern(this._blackHoleEffectIx); } foreach (KeyValuePair <BaseAbilityActor, int> pair in this._addedVelocityActorsAndIndexDic) { if ((pair.Key != null) && (pair.Key.entity != null)) { pair.Key.entity.SetAdditiveVelocityOfIndex(Vector3.zero, pair.Value); pair.Key.entity.SetHasAdditiveVelocity(false); } } this._addedVelocityActorsAndIndexDic.Clear(); } }
public void FireAttackDataEffects(AttackResult attackResult) { if ((attackResult.attackEffectPattern != null) && ((attackResult.hitEffectPattern == AttackResult.HitEffectPattern.Normal) || (attackResult.hitEffectPattern == AttackResult.HitEffectPattern.OnlyAttack))) { AttackPattern.ActAttackEffects(attackResult.attackEffectPattern, this.avatar, attackResult.hitCollision.hitPoint, attackResult.hitCollision.hitDir); } if (attackResult.attackCameraShake != null) { AttackPattern.ActCameraShake(attackResult.attackCameraShake); } }
private bool OnAttackLanded(EvtAttackLanded evt) { BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.attackeeID); if (actor == null) { return(false); } AttackPattern.ActAttackEffects(this.config.AttackEffect, actor.entity, evt.attackResult.hitCollision.hitPoint, evt.attackResult.hitCollision.hitDir); return(true); }
private void CreateExplode(Vector3 pos) { if (this.config.ExplodeAnimEventID != null) { List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(pos, pos, this.config.ExplodeRadius, this.config.ExplodeRadius, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, MixinTargetting.Enemy)); for (int i = 0; i < list.Count; i++) { CollisionResult result = list[i]; BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity); if (collisionResultEntity != null) { Singleton <EventManager> .Instance.FireEvent(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), this.config.ExplodeAnimEventID, result.hitPoint, result.hitForward), MPEventDispatchMode.Normal); } } } }
protected override bool ListenBulletHit(EvtBulletHit evt) { if (!base._bulletAttackDatas.ContainsKey(evt.targetID)) { return(false); } BaseMPIdentity identity = Singleton <MPManager> .Instance.TryGetIdentity(evt.otherID); if (((identity != null) && !identity.isAuthority) && !identity.remoteMode.IsRemoteReceive()) { return(false); } AttackData attackData = base._bulletAttackDatas[evt.targetID]; attackData.isFromBullet = true; bool flag = base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage; bool flag2 = (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget); bool flag3 = true; bool flag4 = base.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh; BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID); BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor; if ((entity is MonoDummyDynamicObject) || ((identity != null) && !identity.remoteMode.IsRemoteReceive())) { flag2 = false; flag = false; flag3 = false; flag4 = false; } else if (evt.hitEnvironment) { flag2 = true; flag4 = false; } else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet)) { Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, base._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal); return(false); } AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID); if (flag2) { bulletActor.Kill(); base._bulletAttackDatas.Remove(evt.targetID); } else { attackData = attackData.Clone(); } if (flag4) { bulletActor.triggerBullet.ResetInside(base.baseConfig.ResetTime); } base._evtsLs.Clear(); if (evt.hitEnvironment) { if (!evt.hitGround) { return(true); } EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData) { hitCollision = evt.hitCollision }; base._evtsLs.Add(item); } else { attackData.hitCollision = evt.hitCollision; base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, base.baseConfig.HitAnimEventID, attackData)); } if (flag) { List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(base.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, base.baseConfig.Targetting)); float y = evt.hitCollision.hitPoint.y; for (int j = 0; j < list.Count; j++) { CollisionResult result = list[j]; BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity); if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID)) { result.hitPoint.y = y; AttackData data2 = attackData.Clone(); AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitDir = result.hitForward, hitPoint = result.hitPoint }; data2.hitCollision = collsion; base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), base.baseConfig.HitAnimEventID, data2)); } } } if (flag3) { Vector3 hitPoint = evt.hitCollision.hitPoint; if (base.baseConfig.ExplodeEffectGround) { hitPoint.y = 0f; } Vector3 hitDir = evt.hitCollision.hitDir; hitDir.y = 0f; base.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, false); } if (base.baseConfig.HitExplodeActions.Length > 0) { for (int k = 0; k < base._evtsLs.Count; k++) { base.actor.abilityPlugin.HandleActionTargetDispatch(base.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(base._evtsLs[k].toID), evt); } } for (int i = 0; i < base._evtsLs.Count; i++) { EvtHittingOther other2 = base._evtsLs[i]; AttackPattern.SendHitEvent(base.actor.runtimeID, other2.toID, other2.animEventID, other2.hitCollision, other2.attackData, false, MPEventDispatchMode.CheckRemoteMode); } return(true); }
protected virtual bool ListenBulletHit(EvtBulletHit evt) { if (!this._bulletAttackDatas.ContainsKey(evt.targetID)) { return(false); } AttackData attackData = this._bulletAttackDatas[evt.targetID]; attackData.isFromBullet = true; bool flag = this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage; bool flag2 = (this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget); bool flag3 = true; bool flag4 = this.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh; BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID); BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor; if (entity is MonoDummyDynamicObject) { flag2 = false; flag = false; flag3 = false; flag4 = false; } else if (evt.hitEnvironment) { flag2 = true; flag4 = false; } else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet)) { Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, this._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal); return(false); } AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID); if (flag2) { if (bulletActor != null) { bulletActor.Kill(); } this._bulletAttackDatas.Remove(evt.targetID); } else { attackData = attackData.Clone(); } if (flag4 && (bulletActor != null)) { bulletActor.triggerBullet.ResetInside(this.baseConfig.ResetTime); } this._evtsLs.Clear(); if (evt.hitEnvironment) { if (!evt.hitGround) { return(true); } EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData) { hitCollision = evt.hitCollision }; this._evtsLs.Add(item); } else { attackData.hitCollision = evt.hitCollision; this._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, this.baseConfig.HitAnimEventID, attackData)); } if (flag) { List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(this.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, this.baseConfig.Targetting)); float y = evt.hitCollision.hitPoint.y; for (int j = 0; j < list.Count; j++) { CollisionResult result = list[j]; BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity); if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID)) { result.hitPoint.y = y; AttackData data2 = attackData.Clone(); AttackResult.HitCollsion collsion = new AttackResult.HitCollsion { hitDir = result.hitForward, hitPoint = result.hitPoint }; data2.hitCollision = collsion; this._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), this.baseConfig.HitAnimEventID, data2)); } } } if (flag3) { Vector3 hitPoint = evt.hitCollision.hitPoint; if (this.baseConfig.ExplodeEffectGround) { hitPoint.y = 0f; } Vector3 hitDir = evt.hitCollision.hitDir; hitDir.y = 0f; bool selfExplode = evt.selfExplode; if (bulletActor != null) { this.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, selfExplode); } } if ((this.baseConfig.HitExplodeActions.Length > 0) && (!evt.selfExplode || !this.baseConfig.MuteSelfHitExplodeActions)) { for (int k = 0; k < this._evtsLs.Count; k++) { if (base.actor.abilityPlugin != null) { base.actor.abilityPlugin.HandleActionTargetDispatch(this.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(this._evtsLs[k].toID), evt); } } } for (int i = 0; i < this._evtsLs.Count; i++) { EvtHittingOther other2 = this._evtsLs[i]; if (this.baseConfig.IsHitChangeTargetDirection && (other2.attackData.hitEffect >= AttackResult.AnimatorHitEffect.ThrowUp)) { BaseAbilityActor actor2 = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(other2.toID); if (actor2 != null) { actor2.entity.transform.forward = -other2.attackData.hitCollision.hitDir; } } Singleton <EventManager> .Instance.FireEvent(other2, MPEventDispatchMode.Normal); } 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); }
protected override void PostInit() { base.PostInit(); this.WeaponHitBox = ((GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource <GameObject>(HIMEKO_WEAPON_HIT_BOX_PATH, BundleType.RESOURCE_FILE), this.weaponTransform.position, Quaternion.identity)).GetComponent <MonoStaticHitboxDetect>(); this.WeaponHitBox.Init(this, AttackPattern.GetLayerMask(this), this.weaponTransform); }
public override void Core() { base.Core(); this._Timer += Time.deltaTime * base.entity.TimeScale; if (this._state != ArsenalState.None) { if (this._state == ArsenalState.Charge) { if (this._chargeIndex < this._cannonList.Count) { CannonInfo cannon = this._cannonList[this._chargeIndex]; if (this._Timer >= cannon.delay) { Vector3 initDir = (Vector3)(Quaternion.FromToRotation(Vector3.forward, base.entity.transform.forward) * cannon.localForward); Vector3 initPos = base.entity.XZPosition + (Quaternion.FromToRotation(Vector3.forward, base.entity.transform.forward) * cannon.localPosition); cannon.position = initPos; cannon.forward = initDir.normalized; cannon.cannonEffects = Singleton <EffectManager> .Instance.TriggerEntityEffectPatternReturnValue(this.config.CannonEffects, initPos, initDir, Vector3.one, base.entity); this.UpdateEffects(cannon.cannonEffects, initPos, initDir); cannon.chargeEffects = Singleton <EffectManager> .Instance.TriggerEntityEffectPatternReturnValue(this.config.ChargeEffects, initPos, initDir, Vector3.one, base.entity); this.UpdateEffects(cannon.chargeEffects, initPos, initDir); Singleton <EffectManager> .Instance.TriggerEntityEffectPatternReturnValue(this.config.HintEffects, this.GetTargetPosition(cannon), Vector3.forward, Vector3.one, base.entity); this._chargeIndex++; } } if (this._Timer > this.config.ChargeTime) { this._state = ArsenalState.Fire; this._Timer = 0f; this._shakeTimer = this.config.FireIntervial; } } else if (this._state == ArsenalState.Fire) { for (int i = 0; i < this._cannonList.Count; i++) { CannonInfo info2 = this._cannonList[i]; info2.fireTimer -= Time.deltaTime * base.entity.TimeScale; if (info2.fireTimer <= 0f) { List <MonoEffect> list = Singleton <EffectManager> .Instance.TriggerEntityEffectPatternReturnValue(this.config.ShootEffects, info2.position, info2.forward, Vector3.one, base.entity); this.UpdateEffects(list, info2.position, info2.forward); Vector2 vector3 = (Vector2)(UnityEngine.Random.insideUnitCircle * this.config.ExplodeRadius); Vector3 vector4 = new Vector3(vector3.x, 0f, vector3.y); Singleton <EffectManager> .Instance.TriggerEntityEffectPatternReturnValue(this.config.ExplodeEffects, this.GetTargetPosition(info2) + vector4, Vector3.forward, Vector3.one, base.entity); this.CreateExplode(this.GetTargetPosition(info2)); info2.fireTimer = this.config.FireIntervial; } } this._shakeTimer -= Time.deltaTime * base.entity.TimeScale; if (this._shakeTimer <= 0f) { ConfigMonsterAnimEvent event2 = SharedAnimEventData.ResolveAnimEvent(this._monster.config, this.config.ShakeAnimEventID); if (event2.CameraShake != null) { AttackPattern.ActCameraShake(event2.CameraShake); } this._shakeTimer = this.config.FireIntervial; } if (this._Timer > this.config.FireTime) { this._state = ArsenalState.Disappear; this._Timer = 0f; } } else if (this._Timer > this.config.ClearTime) { this._state = ArsenalState.None; this.ClearCannons(); } } }