private bool GetTargetCorner(BaseMonoEntity entity, Vector3 sourcePosition, Vector3 targetPosition, ref Vector3 targetCorner)
{
DetourElement element;
this._detours.TryGetValue(entity.GetRuntimeID(), out element);
if (element == null)
{
return(false);
}
if (Miscs.DistancForVec3IgnoreY(targetPosition, element.targetPosition) > this._getPathDisThreshold)
{
this._detours.Remove(entity.GetRuntimeID());
return(false);
}
if (Miscs.DistancForVec3IgnoreY(element.corners[element.targetCornerIndex], sourcePosition) <= element.disReachCornerThreshold)
{
if (element.targetCornerIndex == (element.corners.Length - 1))
{
this._detours.Remove(entity.GetRuntimeID());
targetCorner = targetPosition;
return(true);
}
element.targetCornerIndex++;
targetCorner = element.corners[element.targetCornerIndex];
return(true);
}
targetCorner = element.corners[element.targetCornerIndex];
return(true);
}
private void OnTriggerEnter(Collider other)
{
if (((this._collisionMask.value & (((int)1) << other.gameObject.layer)) != 0) && this._collisionEnabled)
{
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
if (Singleton <RuntimeIDManager> .Instance.ParseCategory(componentInParent.GetRuntimeID()) == 4)
{
if (this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
{
return;
}
}
else if (!componentInParent.IsActive() || this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
{
return;
}
BaseMonoEntity owner = componentInParent;
if (componentInParent is BaseMonoDynamicObject)
{
BaseMonoDynamicObject obj2 = (BaseMonoDynamicObject)componentInParent;
if ((obj2.dynamicType == BaseMonoDynamicObject.DynamicType.EvadeDummy) && (obj2.owner != null))
{
this._enteredIDs.Add(obj2.owner.GetRuntimeID());
}
}
else if (componentInParent is MonoBodyPartEntity)
{
owner = ((MonoBodyPartEntity)componentInParent).owner;
}
if (!(owner is BaseMonoAbilityEntity) || !((BaseMonoAbilityEntity)owner).isGhost)
{
this._enteredIDs.Add(owner.GetRuntimeID());
EvtBulletHit evt = new EvtBulletHit(base._runtimeID, owner.GetRuntimeID())
{
ownerID = base.ownerID
};
Vector3 position = base.transform.position - ((Vector3)((Time.deltaTime * this.BulletTimeScale) * this._rigidbody.velocity));
AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
hitPoint = other.ClosestPointOnBounds(position),
hitDir = this.CreateHitForward()
};
evt.hitCollision = collsion;
Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);
}
}
}
public T CreateActor <T>(BaseMonoEntity entity) where T : BaseActor, new()
{
T item = Activator.CreateInstance <T>();
item.runtimeID = entity.GetRuntimeID();
item.gameObject = entity.gameObject;
item.Init(entity);
this._actorList.Add(item);
this._actors.Add(entity.GetRuntimeID(), item);
ushort index = Singleton <RuntimeIDManager> .Instance.ParseCategory(item.runtimeID);
this._categoryActors[index].Add(item);
this.ProcessInitedActor(item);
Singleton <LevelManager> .Instance.gameMode.RegisterRuntimeID(item.runtimeID);
return(item);
}
public bool GetTargetPosition(BaseMonoEntity entity, Vector3 sourcePosition, Vector3 targetPosition, ref Vector3 targetCorner)
{
if (!this.Raycast(entity.GetRuntimeID(), sourcePosition, targetPosition))
{
targetCorner = targetPosition;
return(true);
}
return(this.GetCornerAndCalcPathWhenNeed(entity, sourcePosition, targetPosition, ref targetCorner));
}
private void OnTriggerEnter(Collider other)
{
if ((this._collisionMask.value & (((int)1) << other.gameObject.layer)) != 0)
{
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
if (Singleton <RuntimeIDManager> .Instance.ParseCategory(componentInParent.GetRuntimeID()) == 4)
{
if (this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
{
return;
}
}
else if (!componentInParent.IsActive() || this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
{
return;
}
if (componentInParent is MonoDummyDynamicObject)
{
BaseMonoDynamicObject obj2 = (BaseMonoDynamicObject)componentInParent;
if ((obj2.dynamicType == BaseMonoDynamicObject.DynamicType.EvadeDummy) && (obj2.owner != null))
{
this._enteredIDs.Add(obj2.owner.GetRuntimeID());
}
}
this._enteredIDs.Add(componentInParent.GetRuntimeID());
this.OnEntityEntered(other, componentInParent);
if (this._stopOnFirstContact)
{
this._animation.Stop();
this._rigidbody.detectCollisions = false;
}
if (this.triggerEnterCallback != null)
{
if (this._follow)
{
base.StartCoroutine(this.WaitEndOfFrameTriggerHit(other, componentInParent));
}
else
{
this.FireTriggerCallback(other, componentInParent);
}
}
}
}
private static bool IsEntityAlreadyInResults(List <CollisionResult> results, BaseMonoEntity entity)
{
for (int i = 0; i < results.Count; i++)
{
if (results[i].entity.GetRuntimeID() == entity.GetRuntimeID())
{
return(true);
}
}
return(false);
}
private void HitBoxTriggerEnterCallback(MonoAnimatedHitboxDetect hitbox, Collider other)
{
if (hitbox.entryName == this.config.ColliderEntryName)
{
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(componentInParent.GetRuntimeID());
if (actor != null)
{
switch (Singleton <RuntimeIDManager> .Instance.ParseCategory(componentInParent.GetRuntimeID()))
{
case 3:
case 4:
{
HashSet <BaseAbilityActor> set = new HashSet <BaseAbilityActor>(Singleton <EventManager> .Instance.GetEnemyActorsOf <BaseAbilityActor>(actor));
if (set.Contains(base.actor))
{
bool flag = false;
foreach (Tuple <MonoAnimatedHitboxDetect, HashSet <BaseAbilityActor> > tuple in this._draggedEnemyList)
{
if (tuple.Item1 == hitbox)
{
flag = true;
break;
}
}
if (flag)
{
HashSet <uint> set2 = null;
foreach (Tuple <MonoAnimatedHitboxDetect, HashSet <uint> > tuple2 in this._touchedEnemyList)
{
if (tuple2.Item1 == hitbox)
{
set2 = tuple2.Item2;
if (tuple2.Item2.Contains(actor.runtimeID))
{
return;
}
}
}
if (set2 != null)
{
set2.Add(actor.runtimeID);
}
}
}
break;
}
}
}
}
}
private void TriggerAbility(BaseMonoEntity target, string ability)
{
EvtAbilityStart evt = new EvtAbilityStart(base.entity.GetRuntimeID(), null)
{
abilityName = ability
};
if (target != null)
{
evt.otherID = target.GetRuntimeID();
}
Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);
}
private void OnTriggerEnter(Collider other)
{
if ((this._collisionMask.value & (((int)1) << other.gameObject.layer)) != 0)
{
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
if (componentInParent.IsActive() && !this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
{
if (componentInParent is MonoDummyDynamicObject)
{
BaseMonoDynamicObject obj2 = (BaseMonoDynamicObject)componentInParent;
if ((obj2.dynamicType == BaseMonoDynamicObject.DynamicType.EvadeDummy) && (obj2.owner != null))
{
this._enteredIDs.Add(obj2.owner.GetRuntimeID());
}
}
this._enteredIDs.Add(componentInParent.GetRuntimeID());
if (this.triggerEnterCallback != null)
{
this.triggerEnterCallback(other);
}
}
}
}
private DetourElement FillDetourElement(BaseMonoEntity entity, Vector3 sourcePosition, Vector3 targetPosition)
{
uint runtimeID = entity.GetRuntimeID();
DetourElement element = this.GetNewDetourElement(entity, sourcePosition, targetPosition);
if (element == null)
{
this.RemoveDetourElement(runtimeID);
return(null);
}
if (this._detours.ContainsKey(runtimeID))
{
this._detours[runtimeID] = element;
return(element);
}
this._detours.Add(runtimeID, element);
return(element);
}
protected virtual void OnEffectiveTriggerEnter(Collider other)
{
for (int i = 0; i < this._insideColliders.Count; i++)
{
if (((this._insideColliders[i] != null) && (this._insideColliders[i].Item1 != null)) && (this._insideColliders[i].Item1.gameObject == other.gameObject))
{
return;
}
}
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
if ((componentInParent != null) && componentInParent.IsActive())
{
Singleton <EventManager> .Instance.FireEvent(new EvtFieldEnter(base._runtimeID, componentInParent.GetRuntimeID()), MPEventDispatchMode.Normal);
int num2 = this._insideColliders.SeekAddPosition <Tuple <Collider, uint> >();
this._insideColliders[num2] = Tuple.Create <Collider, uint>(other, componentInParent.GetRuntimeID());
}
}
public void SetupView(DamageType type, float damage, Vector3 pos, BaseMonoEntity attackee)
{
this._type = type;
this._attackee = attackee;
this._positionOffset = pos - attackee.XZPosition;
this._uiPositionXOffset = 0f;
if (this._textList == null)
{
this.Init();
}
base.transform.position = Singleton <CameraManager> .Instance.GetMainCamera().WorldToUIPoint(pos);
base.transform.SetLocalPositionZ(0f);
bool flag = Singleton <AvatarManager> .Instance.IsLocalAvatar(attackee.GetRuntimeID());
for (int i = 0; i < this._textList.Count; i++)
{
if (i == this._type)
{
this._textList[i].gameObject.SetActive(true);
int num2 = UIUtil.FloorToIntCustom(damage);
this._textList[i].text = (!flag ? num2 : -num2).ToString();
}
else
{
this._textList[i].gameObject.SetActive(false);
}
}
if (flag)
{
this._animation.Play("DisplayAvatarHPDown");
}
else if (type == DamageType.Critical)
{
this._animation.Play("DamageTextCrit");
}
else
{
this._animation.Play("DamageTextMove");
}
this._speedX = UnityEngine.Random.Range((float)-1f, (float)1f);
}
private bool GetCornerAndCalcPathWhenNeed(BaseMonoEntity entity, Vector3 sourcePosition, Vector3 targetPosition, ref Vector3 targetCorner)
{
DetourElement element;
uint runtimeID = entity.GetRuntimeID();
if (this._getPathNumPerFrame >= this._getPathMaxNumPerFrame)
{
return(this.GetTargetCorner(entity, sourcePosition, targetPosition, ref targetCorner));
}
this._detours.TryGetValue(runtimeID, out element);
if (element == null)
{
DetourElement element2 = this.FillDetourElement(entity, sourcePosition, targetPosition);
if (element2 != null)
{
targetCorner = element2.corners[element2.targetCornerIndex];
return(true);
}
targetCorner = targetPosition;
return(true);
}
bool flag = this.GetTargetCorner(entity, sourcePosition, targetPosition, ref targetCorner);
if (flag)
{
return(flag);
}
if ((Time.time - element.lastGetPathTime) <= this._getPathTimeThreshold)
{
return(flag);
}
DetourElement element3 = this.FillDetourElement(entity, sourcePosition, targetPosition);
if (element3 != null)
{
targetCorner = element3.corners[element3.targetCornerIndex];
return(true);
}
targetCorner = targetPosition;
return(true);
}
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++)
{
BaseMonoEntity entity = localAvatar.SubAttackTargetList[i];
EvtAbilityStart start = new EvtAbilityStart(base.entity.GetRuntimeID(), null)
{
abilityName = this.config.AbilityName
};
if (entity != null)
{
start.otherID = entity.GetRuntimeID();
}
Singleton <EventManager> .Instance.FireEvent(start, MPEventDispatchMode.Normal);
}
}
}
private DetourElement GetNewDetourElement(BaseMonoEntity entity, Vector3 sourcePosition, Vector3 targetPosition)
{
NavMeshPath path = new NavMeshPath();
bool flag = NavMesh.CalculatePath(sourcePosition, targetPosition, this._stageAreaWalkMask, path);
for (int i = 0; i < (path.corners.Length - 1); i++)
{
Debug.DrawLine(path.corners[i], path.corners[i + 1], Color.green, 0.1f);
}
this._getPathNumPerFrame++;
DetourElement element = new DetourElement {
id = entity.GetRuntimeID(),
targetPosition = targetPosition,
isCompletePath = flag,
lastGetPathTime = Time.time
};
Vector3[] vectorArray = this.SimplifyPath(sourcePosition, path);
if (vectorArray.Length == 0)
{
return(null);
}
CapsuleCollider componentInChildren = entity.GetComponentInChildren <CapsuleCollider>();
if (componentInChildren != null)
{
element.disReachCornerThreshold = componentInChildren.radius;
}
else
{
element.disReachCornerThreshold = this._disReachCornerThreshold;
}
element.corners = vectorArray;
element.targetCornerIndex = 0;
return(element);
}
public void OnTriggerEnter(Collider other)
{
if (!this._hasTriggerEntered)
{
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
if ((componentInParent != null) && Singleton <AvatarManager> .Instance.IsLocalAvatar(componentInParent.GetRuntimeID()))
{
Singleton <EventManager> .Instance.FireEvent(new EvtFieldEnter(base._runtimeID, componentInParent.GetRuntimeID()), MPEventDispatchMode.Normal);
this._hasTriggerEntered = true;
}
}
}
private void SetHintArrowByScreenPos(MonoHintArrow arrow, BaseMonoEntity entity)
{
bool flag = (((entity != null) && entity.IsActive()) && !Singleton <AvatarManager> .Instance.IsLocalAvatar(entity.GetRuntimeID())) && !Singleton <CameraManager> .Instance.GetMainCamera().IsEntityVisible(entity);
bool isArrowVisibleBefore = (arrow.state == MonoHintArrow.State.Visible) || (arrow.state == MonoHintArrow.State.FadingIn);
bool flag3 = (entity == null) || entity.IsToBeRemove();
if ((arrow.state == MonoHintArrow.State.Hidden) && flag3)
{
UnityEngine.Object.Destroy(arrow.gameObject);
}
else if (isArrowVisibleBefore && !flag)
{
arrow.SetVisible(false);
if (flag3)
{
arrow.SetDestroyUponFadeOut();
}
}
else if (!isArrowVisibleBefore && flag)
{
arrow.SetVisible(true);
}
if (flag)
{
this.UpdateHintArrow(arrow.transform, entity.XZPosition, isArrowVisibleBefore);
}
}
public void AddHintArrow(uint listenRuntimeID)
{
BaseMonoEntity listenEntity = Singleton <EventManager> .Instance.GetEntity(listenRuntimeID);
string path = string.Empty;
if (Singleton <RuntimeIDManager> .Instance.ParseCategory(listenRuntimeID) == 4)
{
path = "UI/HintArrowAlt/HintArrowMonsterAlt";
}
else if (Singleton <RuntimeIDManager> .Instance.ParseCategory(listenRuntimeID) == 3)
{
path = "UI/HintArrowAlt/HintArrowAvatarAlt";
}
else
{
if (!(listenEntity is BaseMonoDynamicObject) || (Singleton <EventManager> .Instance.GetActor(listenEntity.GetRuntimeID()) == null))
{
throw new Exception("Invalid Type or State!");
}
path = "UI/HintArrowAlt/HintArrowExitAlt";
}
MonoHintArrow component = UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(path, BundleType.RESOURCE_FILE)).GetComponent <MonoHintArrow>();
component.Init(listenRuntimeID, listenEntity);
component.transform.SetParent(this._hintRing.transform, false);
this._hintArrowLs.Add(component);
}
public override void Init(BaseMonoEntity entity)
{
base.runtimeID = entity.GetRuntimeID();
}
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);
}
private void SelectSubTargets(int targetAmount)
{
BaseMonoEntity attackTarget = base.actor.entity.GetAttackTarget();
if ((attackTarget != null) && !this._subSelectTargetList.Contains(attackTarget))
{
this._subSelectTargetList.Add(attackTarget);
this.AddSubAttackTarget(attackTarget);
if (attackTarget is BaseMonoMonster)
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(attackTarget.GetRuntimeID());
if ((actor != null) && !string.IsNullOrEmpty(this.config.SubTargetModifierName))
{
actor.abilityPlugin.ApplyModifier(base.instancedAbility, this.config.SubTargetModifierName);
}
}
}
List <BaseMonoMonster> allMonsters = Singleton <MonsterManager> .Instance.GetAllMonsters();
allMonsters.Sort(new Comparison <BaseMonoMonster>(this.NearestTargetCompare));
for (int i = 0; i < allMonsters.Count; i++)
{
BaseMonoMonster item = allMonsters[i];
MonsterActor actor2 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(item.GetRuntimeID());
if (((item != attackTarget) && (actor2 != null)) && ((this._subSelectTargetList.Count < targetAmount) && !this._subSelectTargetList.Contains(item)))
{
if (!string.IsNullOrEmpty(this.config.SubTargetModifierName))
{
actor2.abilityPlugin.ApplyModifier(base.instancedAbility, this.config.SubTargetModifierName);
}
this._subSelectTargetList.Add(item);
this.AddSubAttackTarget(item);
}
}
}
public override void OnStart()
{
BaseMonoEntity component = base.GetComponent <BaseMonoEntity>();
this._actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(component.GetRuntimeID());
}
protected override void OnDurationTimeOut()
{
for (int i = 0; i < this._insideColliders.Count; i++)
{
if ((this._insideColliders[i] != null) && (this._insideColliders[i].Item1 != null))
{
BaseMonoEntity componentInParent = this._insideColliders[i].Item1.GetComponentInParent <BaseMonoEntity>();
if (componentInParent != null)
{
Singleton <EventManager> .Instance.FireEvent(new EvtFieldExit(base._runtimeID, componentInParent.GetRuntimeID()), MPEventDispatchMode.Normal);
}
}
}
this._insideColliders.Clear();
base.OnDurationTimeOut();
}
public static string GetDebugEntityName(BaseMonoEntity entity)
{
if (entity == null)
{
return("<!null>");
}
return(string.Format("<{0}({1:x})>", Truncate(entity.gameObject.name, 10), entity.GetRuntimeID()));
}
public override void OnAbilityTriggered(EvtAbilityStart evt)
{
BaseMonoEntity attackTarget = base.actor.entity.GetAttackTarget();
if (attackTarget != null)
{
this._pullActor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(attackTarget.GetRuntimeID());
}
if (this._pullActor != null)
{
this._pullActor.entity.SetHasAdditiveVelocity(true);
Vector3 vector = base.entity.transform.position - attackTarget.transform.position;
if (vector.magnitude < base.instancedAbility.Evaluate(this.config.PullRadius))
{
vector.Normalize();
this._pullActor.entity.SetAdditiveVelocity((Vector3)(vector * base.instancedAbility.Evaluate(this.config.PullVelocity)));
}
}
}
protected virtual void OnEffectiveTriggerExit(Collider other)
{
if (other != null)
{
BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
if (componentInParent != null)
{
Singleton <EventManager> .Instance.FireEvent(new EvtFieldExit(base._runtimeID, componentInParent.GetRuntimeID()), MPEventDispatchMode.Normal);
}
int num = -1;
for (int i = 0; i < this._insideColliders.Count; i++)
{
if (((this._insideColliders[i] != null) && (this._insideColliders[i].Item1 != null)) && (this._insideColliders[i].Item1.gameObject == other.gameObject))
{
num = i;
}
}
if (num >= 0)
{
this._insideColliders[num] = null;
}
}
}
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();
}
}
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));
}
}
}
public static void TestAndActHit(string attackName, ConfigEntityAttackPattern patternConfig, IAttacker attacker, List <CollisionResult> results)
{
AttackResult.HitCollsion collsion4;
List <CollisionResult> list = FilterRealAttackeesByBodyParts(attackName, patternConfig, attacker, results);
switch (Singleton <RuntimeIDManager> .Instance.ParseCategory(attacker.GetRuntimeID()))
{
case 3:
foreach (CollisionResult result in list)
{
BaseMonoEntity entity = result.entity;
if (((entity != null) && (entity.GetRuntimeID() != attacker.GetRuntimeID())) && (entity.IsActive() || (Singleton <RuntimeIDManager> .Instance.ParseCategory(entity.GetRuntimeID()) == 4)))
{
switch (Singleton <RuntimeIDManager> .Instance.ParseCategory(entity.GetRuntimeID()))
{
case 3:
case 4:
case 6:
case 7:
if (Singleton <LevelManager> .Instance.gameMode.IsEnemy(attacker.GetRuntimeID(), entity.GetRuntimeID()))
{
goto Label_0103;
}
break;
}
}
continue;
Label_0103:
collsion4 = new AttackResult.HitCollsion();
collsion4.hitDir = result.hitForward;
collsion4.hitPoint = result.hitPoint;
AttackResult.HitCollsion hitCollision = collsion4;
SendHitEvent(attacker.GetRuntimeID(), entity.GetRuntimeID(), attackName, hitCollision, null, false, MPEventDispatchMode.CheckRemoteMode);
}
return;
case 4:
foreach (CollisionResult result2 in list)
{
BaseMonoEntity entity2 = result2.entity;
if (((entity2 != null) && (entity2.GetRuntimeID() != attacker.GetRuntimeID())) && entity2.IsActive())
{
switch (Singleton <RuntimeIDManager> .Instance.ParseCategory(entity2.GetRuntimeID()))
{
case 3:
case 4:
case 6:
if (Singleton <LevelManager> .Instance.gameMode.IsEnemy(attacker.GetRuntimeID(), entity2.GetRuntimeID()))
{
goto Label_021F;
}
break;
}
}
continue;
Label_021F:
collsion4 = new AttackResult.HitCollsion();
collsion4.hitDir = result2.hitForward;
collsion4.hitPoint = result2.hitPoint;
AttackResult.HitCollsion collsion2 = collsion4;
SendHitEvent(attacker.GetRuntimeID(), entity2.GetRuntimeID(), attackName, collsion2, null, false, MPEventDispatchMode.CheckRemoteMode);
}
return;
case 7:
foreach (CollisionResult result3 in list)
{
BaseMonoEntity entity3 = result3.entity;
if (((entity3 != null) && (entity3.GetRuntimeID() != attacker.GetRuntimeID())) && entity3.IsActive())
{
switch (Singleton <RuntimeIDManager> .Instance.ParseCategory(entity3.GetRuntimeID()))
{
case 3:
case 4:
case 6:
if (Singleton <LevelManager> .Instance.gameMode.IsEnemy(attacker.GetRuntimeID(), entity3.GetRuntimeID()))
{
goto Label_033F;
}
break;
}
}
continue;
Label_033F:
collsion4 = new AttackResult.HitCollsion();
collsion4.hitDir = result3.hitForward;
collsion4.hitPoint = result3.hitPoint;
AttackResult.HitCollsion collsion3 = collsion4;
SendHitEvent(attacker.GetRuntimeID(), entity3.GetRuntimeID(), attackName, collsion3, null, false, MPEventDispatchMode.CheckRemoteMode);
}
return;
}
throw new Exception("Invalid Type or State!");
}
private void ClearSubTargets()
{
if (this._subSelectTargetList.Count > 0)
{
for (int i = 0; i < this._subSelectTargetList.Count; i++)
{
BaseMonoEntity entity = this._subSelectTargetList[i];
if (entity != null)
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(entity.GetRuntimeID());
if ((actor != null) && !string.IsNullOrEmpty(this.config.SubTargetModifierName))
{
actor.abilityPlugin.TryRemoveModifier(base.instancedAbility, this.config.SubTargetModifierName);
}
}
}
this._subSelectTargetList.Clear();
}
this.ClearAllSubAttackTargets();
}
