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