private void SetRandomDirectionWithWallcheck(Vector3 charDirection)
{
int num = Mathf.FloorToInt((this.randAngelMax - this.randAngelMin) / 12f);
float num2 = -1f;
Vector3 zero = Vector3.zero;
float num3 = (this.randAngelMax <= this.randAngelMin) ? this.randAngelMax : this.randAngelMin;
for (int i = 0; i < num; i++)
{
Vector3 forward = (Vector3)(Quaternion.AngleAxis(num3 + (i * 12f), Vector3.up) * charDirection);
float num5 = CollisionDetectPattern.GetRaycastDistance(base._aiEntity.RootNodePosition, forward, 10f, 0.5f, InLevelData.STAGE_COLLIDER_LAYER);
if (num5 > num2)
{
num2 = num5;
zero = forward;
}
}
if (num2 == 10f)
{
zero = (Vector3)(Quaternion.AngleAxis(UnityEngine.Random.Range(this.randAngelMin, this.randAngelMax), Vector3.up) * charDirection);
}
this._toDirection = zero;
this._toDirection.y = 0f;
this._toDirection.Normalize();
}
public static void CylinderCollisionDetectAttack(string attackName, ConfigEntityAttackPattern patternConfig, IAttacker attacker, LayerMask layerMask)
{
CylinderCollisionDetect detect = (CylinderCollisionDetect)patternConfig;
Vector3 cylinderCenterPoint = attacker.XZPosition + ((Vector3)(attacker.FaceDirection * detect.CenterZOffset));
List <CollisionResult> results = CollisionDetectPattern.CylinderCollisionDetectBySphere(attacker.XZPosition, cylinderCenterPoint, detect.Radius, detect.Height, layerMask);
TestAndActHit(attackName, patternConfig, attacker, results);
}
public static void RectCollisionDetectAttack(string attackName, ConfigEntityAttackPattern patternConfig, IAttacker attacker, LayerMask layerMask)
{
RectCollisionDetect detect = (RectCollisionDetect)patternConfig;
Vector3 recCenterPoint = new Vector3(attacker.XZPosition.x, attacker.XZPosition.y + detect.CenterYOffset, attacker.XZPosition.z);
List <CollisionResult> results = CollisionDetectPattern.RectCollisionDetectByRay(recCenterPoint, detect.OffsetZ, attacker.FaceDirection, detect.Width, detect.Distance, layerMask);
TestAndActHit(attackName, patternConfig, attacker, results);
}
public static void FanCollisionDetectAttack(string attackName, ConfigEntityAttackPattern patternConfig, IAttacker attacker, LayerMask layerMask)
{
FanCollisionDetect detect = (FanCollisionDetect)patternConfig;
Vector3 fanCenterPoint = new Vector3(attacker.XZPosition.x, (attacker.XZPosition.y + detect.CenterYOffset) + (!detect.FollowRootNodeY ? 0f : attacker.GetAttachPoint("RootNode").transform.position.y), attacker.XZPosition.z);
List <CollisionResult> results = CollisionDetectPattern.MeleeFanCollisionDetectBySphere(fanCenterPoint, detect.OffsetZ, attacker.FaceDirection, detect.Radius * (1f + attacker.Evaluate(detect.RadiusRatio)), detect.FanAngle, detect.MeleeRadius, detect.MeleeFanAngle, layerMask);
TestAndActHit(attackName, patternConfig, attacker, results);
}
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 override void OnAbilityTriggered(EvtAbilityStart evt)
{
Vector3 vector;
if (this._blackHoleTimer.isActive)
{
this.KillBlackHole(true);
}
BaseMonoEntity entity = null;
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)
{
vector = entity.XZPosition + new Vector3(0f, 0.5f, 0f);
}
else
{
Vector3 origin = base.entity.XZPosition + new Vector3(0f, 0.5f, 0f);
vector = CollisionDetectPattern.GetRaycastPoint(origin, base.entity.transform.forward, base.instancedAbility.Evaluate(this.config.CreationZOffset), 0.2f, ((int)1) << InLevelData.STAGE_COLLIDER_LAYER);
}
this._fieldActor = Singleton <DynamicObjectManager> .Instance.CreateAbilityTriggerField(vector, base.entity.transform.forward, base.actor, base.instancedAbility.Evaluate(this.config.Radius), MixinTargetting.Enemy, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), false);
if ((this.config.CreationEffect != null) && (this.config.CreationEffect.EffectPattern != null))
{
this._blackHoleEffectIx = Singleton <EffectManager> .Instance.CreateIndexedEntityEffectPattern(this.config.CreationEffect.EffectPattern, this._fieldActor.triggerField);
}
if (this.config.ApplyAttackerWitchTimeRatio && (evt.TriggerEvent != null))
{
EvtEvadeSuccess triggerEvent = evt.TriggerEvent as EvtEvadeSuccess;
if (triggerEvent != null)
{
MonsterActor actor2 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(triggerEvent.attackerID);
if (actor2 != null)
{
ConfigMonsterAnimEvent event2 = SharedAnimEventData.ResolveAnimEvent(actor2.config, triggerEvent.skillID);
if (event2 != null)
{
this._blackHoleTimer.timespan *= event2.AttackProperty.WitchTimeRatio;
}
}
}
}
this._blackHoleTimer.Reset(true);
}
private void CreateField(EvtAbilityStart evt)
{
Vector3 vector;
if (this._timer.isActive)
{
this.StopField();
}
BaseMonoEntity attackTarget = null;
float maxDistance = base.instancedAbility.Evaluate(this.config.CreationZOffset);
float num2 = base.instancedAbility.Evaluate(this.config.CreationXOffset);
switch (this.config.TriggerPositionType)
{
case TriggerFieldExMixin.PositionType.Caster:
attackTarget = base.actor.entity;
break;
case TriggerFieldExMixin.PositionType.AttackTarget:
attackTarget = base.entity.GetAttackTarget();
if (attackTarget == null)
{
maxDistance += base.instancedAbility.Evaluate(this.config.NoAttackTargetZOffset);
}
break;
case TriggerFieldExMixin.PositionType.Target:
if (evt.otherID != 0)
{
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.otherID);
if ((actor != null) && (actor.entity != null))
{
attackTarget = actor.entity;
}
}
break;
}
Vector3 vector2 = (Vector3)(Vector3.Cross(Vector3.up, base.entity.transform.forward).normalized *num2);
if (attackTarget != null)
{
vector = (attackTarget.XZPosition + new Vector3(0f, 0.5f, 0f)) + vector2;
}
else
{
attackTarget = base.actor.entity;
Vector3 origin = (base.entity.XZPosition + new Vector3(0f, 0.5f, 0f)) + vector2;
vector = CollisionDetectPattern.GetRaycastPoint(origin, base.entity.transform.forward, maxDistance, 0.2f, ((int)1) << InLevelData.STAGE_COLLIDER_LAYER);
}
this._fieldActor = Singleton <DynamicObjectManager> .Instance.CreateAbilityTriggerField(vector, attackTarget.transform.forward, base.actor, base.instancedAbility.Evaluate(this.config.Radius), this.config.Targetting, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), this.config.Follow);
}
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);
}
}
}
}
public static void CylinderCollisionDetectTargetLockedAttack(string attackName, ConfigEntityAttackPattern patternConfig, IAttacker attacker, LayerMask layerMask)
{
Vector3 xZPosition;
CylinderCollisionDetectTargetLocked locked = (CylinderCollisionDetectTargetLocked)patternConfig;
if ((attacker.AttackTarget != null) && attacker.AttackTarget.IsActive())
{
xZPosition = attacker.AttackTarget.XZPosition;
}
else
{
xZPosition = attacker.XZPosition;
}
List <CollisionResult> results = CollisionDetectPattern.CylinderCollisionDetectBySphere(attacker.XZPosition, xZPosition, locked.Radius * (1f + attacker.Evaluate(locked.RadiusRatio)), locked.Height, layerMask);
TestAndActHit(attackName, patternConfig, attacker, results);
}
private void SkillIDChangedCallback(string from, string to)
{
if (to == this._attackRunStopSkillID)
{
if (CollisionDetectPattern.CircleCollisionDetectBySphere(base.RootNodePosition, 0f, base.FaceDirection, base.config.CommonArguments.CollisionRadius * 3f, ((int)1) << InLevelData.AVATAR_LAYER).Count > 0)
{
this.SetTrigger(this._attackRunTriggerID);
this._isInRun = false;
}
else
{
this._isInRun = true;
}
}
else
{
this.ResetTrigger(this._attackRunTriggerID);
this._isInRun = false;
}
}
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);
}