public override bool ClientCastSkillByID(int skillID)
{
if (this.owner.IsClientDominate)
{
Skill skill = DataReader <Skill> .Get(skillID);
if (skill.rush > 0)
{
this.owner.GetSkillManager().SetTargetBySkillID(skillID, TargetRangeType.SkillRange, (float)skill.rush);
}
else
{
this.owner.GetSkillManager().SetTargetBySkillID(skillID, TargetRangeType.SkillRange, 0f);
}
if (skill.rush > 0 && this.owner.AITarget != null && this.owner.AITarget.Actor)
{
float num = XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), this.owner.AITarget.Actor.FixTransform.get_position()) - (float)skill.reach.get_Item(0) * 0.01f - XUtility.GetHitRadius(this.owner.AITarget.Actor.FixTransform);
if (!this.owner.IsStatic && !this.owner.IsDizzy && !this.owner.IsWeak && !this.owner.IsFixed && !this.owner.IsAssault && !this.owner.IsHitMoving && num <= (float)skill.rush * 0.01f && num > 0f && this.CheckClientHandleSkillByID(skillID))
{
this.ClientBeginAssault(skillID, this.owner.AITarget);
return(false);
}
}
return(base.ClientCastSkillByID(skillID));
}
return(base.ClientCastSkillByID(skillID));
}
public bool MoveToCurrentBatchPoint()
{
if (this.owner.IsWeak)
{
return(false);
}
if (!this.ownerActor)
{
return(false);
}
if (this.owner.AITarget != null)
{
return(false);
}
List <EntityParent> values = EntityWorld.Instance.AllEntities.Values;
for (int i = 0; i < values.get_Count(); i++)
{
if (values.get_Item(i).Camp != this.owner.Camp)
{
return(false);
}
}
Vector2 zero = Vector2.get_zero();
if (InstanceManager.GetCurrentBattlePathPoint(out zero))
{
if (XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), new Vector3(zero.x, this.ownerActor.FixTransform.get_position().y, zero.y)) > 0.5f)
{
this.ownerActor.MoveToPoint(new Vector3(zero.x, this.ownerActor.FixTransform.get_position().y, zero.y), 0f, null);
}
return(true);
}
return(false);
}
public bool CheckTargetDistanceBySkillIndex(int skillIndex)
{
int key;
if (!this.GetSkillIDBySkillIndex(skillIndex, out key))
{
return(false);
}
Skill skill = DataReader <Skill> .Get(key);
if (skill == null)
{
return(false);
}
if (this.owner.AITarget == null)
{
return(false);
}
if (this.owner.AITarget.Actor == null || this.owner.AITarget.Actor.FixTransform == null)
{
return(false);
}
if (XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), this.owner.AITarget.Actor.FixTransform.get_position()) <= (float)skill.reach.get_Item(0) * 0.01f + XUtility.GetHitRadius(this.owner.AITarget.Actor.FixTransform) && XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), this.owner.AITarget.Actor.FixTransform.get_position()) >= skill.reachLimit * 0.01f - XUtility.GetHitRadius(this.owner.AITarget.Actor.FixTransform))
{
float num = Vector3.Angle(this.ownerActor.FixTransform.get_forward(), new Vector3(this.owner.AITarget.Actor.FixTransform.get_position().x, this.ownerActor.FixTransform.get_position().y, this.owner.AITarget.Actor.FixTransform.get_position().z) - this.ownerActor.FixTransform.get_position());
if (num <= (float)skill.reach.get_Item(1) || this.ownerActor.FixTransform.get_position() == this.owner.AITarget.Actor.FixTransform.get_position())
{
return(true);
}
}
return(false);
}
public override bool FindAttackTarget()
{
AttackTarget = null;
Dictionary <long, Monster> hero = ActorManager.Instance.EnemyDict;
float temp, dire = float.MaxValue;
foreach (Actor actor in hero.Values)
{
if (actor.IsDead)
{
continue;
}
temp = XUtility.DistanceNoY(actor.transform.position, transform.position);
if (temp <= CurSkill.Attr.FindDist && temp < dire)
{
dire = temp;
AttackTarget = actor;
}
}
if (null != AttackTarget)
{
SetBool("findTarget", true);
//mCurSpeed = Attr.CrouchSpeed;
return(true);
}
else
{
SetBool("findTarget", false);
//mCurSpeed = Attr.MoveSpeed;
return(false);
}
}
public override bool MoveToSkillTarget(float skillReach)
{
if (this.GetEntity().AITarget == null)
{
return(false);
}
if (!this.GetEntity().AITarget.Actor)
{
return(false);
}
float num = XUtility.DistanceNoY(base.FixTransform.get_position(), this.GetEntity().AITarget.Actor.FixTransform.get_position()) - (skillReach + XUtility.GetHitRadius(this.GetEntity().AITarget.Actor.FixTransform));
if (num <= -0.05f)
{
base.StopMoveToPoint();
return(false);
}
if (this.CurActionStatus != "run" && !this.CanChangeActionTo("run", true, 0, false) && ActionStatusName.IsSkillAction(this.CurActionStatus) && !this.GetEntity().IsMoveCast&& !base.IsUnderTermination)
{
return(false);
}
Vector3 vector = new Vector3(this.GetEntity().AITarget.Actor.FixTransform.get_position().x - base.FixTransform.get_position().x, 0f, this.GetEntity().AITarget.Actor.FixTransform.get_position().z - base.FixTransform.get_position().z);
Vector3 normalized = vector.get_normalized();
Vector3 aIMoveFixPoint = base.GetAIMoveFixPoint(base.FixTransform.get_position(), this.GetEntity().AITarget.Actor.FixTransform.get_position(), normalized, num, XUtility.GetHitRadius(base.FixTransform));
this.MoveToPoint(aIMoveFixPoint, 0f, null);
this.GetEntity().AIToPoint = new XPoint
{
position = aIMoveFixPoint
};
return(true);
}
public void ServerAssault(Vector3 endPosition, int actionPriority)
{
this.assaultEndPos = endPosition;
this.assaultSpeed = base.OriginAssaultSpeed * base.LogicMoveSpeed / base.ModelOriginSpeed;
this.assaultTime = XUtility.DistanceNoY(base.FixTransform.get_position(), endPosition) / this.assaultSpeed;
base.ServerCastAction("rush", actionPriority, ActorParent.EffectFrameSetMode.Server, 1f, 0, 0, string.Empty);
}
protected void CheckFixStand()
{
float num = XUtility.DistanceNoY(this.transform.get_position(), this.npcPosition);
if (num > TaskNPCBehavior.NavToPointStopDistance)
{
this.transform.set_position(MySceneManager.GetTerrainPoint(this.npcPosition.x, this.npcPosition.z, this.npcPosition.y));
this.navMeshAgent.Warp(this.transform.get_position());
}
if (this.transform.get_forward() != this.npcDirection)
{
this.transform.set_forward(this.npcDirection);
}
if (this.IsFollowingSelf)
{
this.IsFollowingSelf = false;
}
if (this.IsNavToPoint)
{
this.IsNavToPoint = false;
}
this.StopNavAgent();
base.CastAction(base.DefaultIdleActionStatus);
this.UpdateState(new TaskNPCBehavior.TaskNPCState
{
state = TaskNPCBehavior.TaskNPCState.TaskNPCStateType.None,
Position = this.transform.get_position(),
Direction = this.transform.get_forward()
});
}
public override bool ClientCastSkillByID(int skillID)
{
if (!GlobalBattleNetwork.Instance.IsServerEnable)
{
if (this.IsOpenLog)
{
Debug.LogError("return 4");
}
return(false);
}
Skill skill = DataReader <Skill> .Get(skillID);
if (skill.rush > 0)
{
this.owner.GetSkillManager().SetTargetBySkillID(skillID, TargetRangeType.SkillRange, (float)skill.rush);
}
else
{
this.owner.GetSkillManager().SetTargetBySkillID(skillID, TargetRangeType.SkillRange, 0f);
}
if (skill.rush > 0 && this.owner.AITarget != null && this.owner.AITarget.Actor)
{
float num = XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), this.owner.AITarget.Actor.FixTransform.get_position()) - (float)skill.reach.get_Item(0) * 0.01f - XUtility.GetHitRadius(this.owner.AITarget.Actor.FixTransform);
if (!this.owner.IsStatic && !this.owner.IsDizzy && !this.owner.IsWeak && !this.owner.IsFixed && !this.owner.IsAssault && !this.owner.IsHitMoving && num <= (float)skill.rush * 0.01f && num > 0f && (!ActionStatusName.IsSkillAction(this.ownerActor.CurActionStatus) || this.ownerActor.IsUnderTermination) && this.ownerActor.CanChangeActionTo("rush", true, 0, false) && this.CheckClientHandleSkillByID(skillID))
{
this.ClientBeginAssault(skillID, this.owner.AITarget);
return(false);
}
}
return(base.ClientCastSkillByID(skillID));
}
public virtual bool CheckAttackRange()
{
if (AttackTarget != null && CurSkill != null &&
XUtility.DistanceNoY(AttackTarget.transform.position - transform.position) <= CurSkill.Attr.AttackDist)
{
return(true);
}
return(false);
}
public void ClientAssault(long targetID, int skillID, Vector3 endPosition)
{
this.assaultTargetID = targetID;
this.assaultEndSkillID = skillID;
this.assaultEndSkillDistance = ((DataReader <Skill> .Get(this.assaultEndSkillID).reach == null || DataReader <Skill> .Get(this.assaultEndSkillID).reach.get_Count() <= 1) ? 0.05f : ((float)DataReader <Skill> .Get(this.assaultEndSkillID).reach.get_Item(0) * 0.01f));
this.assaultEndPos = endPosition;
this.assaultSpeed = base.OriginAssaultSpeed * base.LogicMoveSpeed / base.ModelOriginSpeed;
this.assaultTime = XUtility.DistanceNoY(base.FixTransform.get_position(), endPosition) / this.assaultSpeed;
this.ChangeAction("rush", false, true, 1f, 0, 0, string.Empty);
}
private bool DealKeyPathPoint(Vector3 pre_point, Vector3 current_point)
{
float num = XUtility.DistanceNoY(pre_point, current_point);
if (num < RadarManager.Instance.DISTANCE_3D_MIN)
{
return(false);
}
this.InstantiatePathPoint(current_point);
return(true);
}
protected void CheckFollow()
{
float num = XUtility.DistanceNoY(this.FixTransform.get_position(), this.Entity.Owner.Actor.FixTransform.get_position());
if (num <= ActorCityPet.StopDistance)
{
this.StopFollow();
}
else if (num > ActorCityPet.StartDistance)
{
this.Follow();
}
}
private void InsertPathPoint(Vector3 pre_point, Vector3 current_point)
{
float num = XUtility.DistanceNoY(pre_point, current_point);
if (num > RadarManager.Instance.DISTANCE_3D_INSERT)
{
int num2 = (int)(num / RadarManager.Instance.DISTANCE_3D_INSERT);
for (int i = 1; i <= num2; i++)
{
this.InstantiatePathPoint(Vector3.Lerp(pre_point, current_point, 1f / (float)num2 * (float)i));
}
}
}
protected void CheckNavToPoint()
{
float num = XUtility.DistanceNoY(this.transform.get_position(), this.npcPosition);
if (num <= TaskNPCBehavior.NavToPointStopDistance)
{
this.StopNavToPoint();
}
else
{
this.NavToPoint();
}
}
protected void ControllerNavMeshMove(Vector3 pos, float radius = 0.5f, System.Action callback = null)
{
IsClearTargetPosition = false;
Agent.radius = radius;
NavMeshPosition = FixNavMeshPosition(pos);
NavMesh.CalculatePath(Agent.transform.position, NavMeshPosition, NavMesh.AllAreas, mNavMeshPath);
if (mNavMeshPath.corners.Length < 1)
{
IsClearTargetPosition = true;
return;
}
MoveEndCallBack = callback;
//起点和当前位置不同时
if (XUtility.DistanceNoY(mNavMeshPath.corners[0], transform.position) > NextPace || mNavMeshPath.corners.Length == 1)
{
ToCorner = 0;
if (XUtility.DistanceNoY(mNavMeshPath.corners[0], transform.position) <= NextPace)
{
IsClearTargetPosition = true;
transform.position = mNavMeshPath.corners[0];
if (MoveEndCallBack != null)
{
MoveEndCallBack();
MoveEndCallBack = null;
}
return;
}
}
else
{
ToCorner = 1;
if (XUtility.DistanceNoY(mNavMeshPath.corners[0], transform.position) <= NextPace)
{
transform.position = mNavMeshPath.corners[0];
}
}
LeftLength = XUtility.DistanceNoY(transform.position, mNavMeshPath.corners[ToCorner]);
//转向
TurnToPos(mNavMeshPath.corners[ToCorner]);
}
public override bool FindFollowTarget()
{
if (null == FollowTarget)
{
if (XUtility.DistanceNoY(GamingSys.Instance.Player.transform.position, transform.position) <= CurSkill.Attr.FindDist)
{
FollowTarget = GamingSys.Instance.Player;
GamingSys.Instance.Player.AddTeammate(this);
}
#if UNITY_EDITOR
XUtility.DrawCircle(transform.position, transform.forward, CurSkill.Attr.FindDist, Color.green, 1f);
#endif
}
return(FollowTarget != null);
}
protected Vector3 CommonMove()
{
NextPace = MovingSpeed * Time.deltaTime;
if (XUtility.DistanceNoY(transform.position, NavMeshPosition) <= 0.1f ||
ToCorner == mNavMeshPath.corners.Length ||
(NextPace >= LeftLength && ToCorner == mNavMeshPath.corners.Length - 1))
{
if (!IsClearTargetPosition)
{
// 清除行走目标方向，停下，恢复Idle，到达目的地
StopMoveToPoint();
transform.position = NavMeshPosition;
LeftLength = 0;
if (MoveEndCallBack != null)
{
MoveEndCallBack();
MoveEndCallBack = null;
}
}
}
else if (mNavMeshPath.corners.Length > 0 &&
(XUtility.DistanceNoY(transform.position, mNavMeshPath.corners[ToCorner]) <= 0.1f || (NextPace > LeftLength)))
{
if (!IsClearTargetPosition)
{
//到达拐点
transform.position = mNavMeshPath.corners[ToCorner];
ToCorner++;
if (ToCorner < mNavMeshPath.corners.Length)
{
transform.LookAt(mNavMeshPath.corners[ToCorner]);
LeftLength = XUtility.DistanceNoY(transform.position, mNavMeshPath.corners[ToCorner]);
}
}
}
else if (!IsClearTargetPosition && ToCorner < mNavMeshPath.corners.Length)
{
// 继续走
MovingDirection = XUtility.DirectionNoY(mNavMeshPath.corners[ToCorner] - transform.position).normalized;
}
return(MovingSpeed * MovingDirection);
}
public static bool GetRoughPathPoint(float desX, float desZ, float accuracy, out List <Vector3> pathPoint)
{
XUtility.mRoughPathPoint.Clear();
pathPoint = XUtility.mRoughPathPoint;
Vector3 position;
if (!XUtility.GetTerrainPoint(desX, desZ, 0f, out position))
{
return(false);
}
NavMeshHit navMeshHit;
if (!NavMesh.SamplePosition(position, ref navMeshHit, 500f, -1))
{
return(false);
}
position = navMeshHit.get_position();
Vector3 position2 = EntityWorld.Instance.EntSelf.Actor.FixTransform.get_position();
if (!NavMesh.SamplePosition(EntityWorld.Instance.EntSelf.Actor.FixTransform.get_position(), ref navMeshHit, 500f, -1))
{
return(false);
}
Vector3 position3 = navMeshHit.get_position();
NavMeshPath navMeshPath = new NavMeshPath();
if (!NavMesh.CalculatePath(position2, position, -1, navMeshPath))
{
return(false);
}
if (navMeshPath.get_corners().Length < 2)
{
return(false);
}
pathPoint.AddRange(navMeshPath.get_corners());
if (XUtility.DistanceNoY(position3, navMeshPath.get_corners()[0]) > accuracy)
{
pathPoint.Insert(0, position3);
}
if (XUtility.DistanceNoY(position2, position3) > accuracy)
{
pathPoint.Insert(0, position2);
}
return(true);
}
protected List <Vector3> GetAccuratePointByCircle(Vector3 curPosition, XPoint basePoint, float range, float hitRange, float casterRadius)
{
Vector3 vector = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y, basePoint.rotation.get_eulerAngles().z) * Vector3.get_forward();
Vector3 vector2 = basePoint.position - vector * range;
List <Vector3> list = new List <Vector3>();
SortedDictionary <float, List <Vector3> > sortedDictionary = new SortedDictionary <float, List <Vector3> >();
Vector3 vector3 = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y - 90f, basePoint.rotation.get_eulerAngles().z) * Vector3.get_forward();
Vector3 vector4 = Quaternion.Euler(basePoint.rotation.get_eulerAngles().x, basePoint.rotation.get_eulerAngles().y + 90f, basePoint.rotation.get_eulerAngles().z) * Vector3.get_forward();
Vector3 vector5 = vector2 + vector3 * (range + hitRange + this.safeDistance);
Vector3 vector6 = vector2 + vector4 * (range + hitRange + this.safeDistance);
float num = XUtility.DistanceNoY(curPosition, vector5);
float num2 = XUtility.DistanceNoY(curPosition, vector6);
if (SystemConfig.IsOpenEffectDrawLine)
{
Debug.DrawLine(curPosition, vector5, Color.get_blue(), 2f);
Debug.DrawLine(curPosition, vector6, Color.get_white(), 2f);
}
if (!sortedDictionary.ContainsKey(num))
{
sortedDictionary.Add(num, new List <Vector3>());
}
sortedDictionary.get_Item(num).Add(vector5);
if (!sortedDictionary.ContainsKey(num2))
{
sortedDictionary.Add(num2, new List <Vector3>());
}
sortedDictionary.get_Item(num2).Add(vector6);
using (SortedDictionary <float, List <Vector3> > .Enumerator enumerator = sortedDictionary.GetEnumerator())
{
while (enumerator.MoveNext())
{
KeyValuePair <float, List <Vector3> > current = enumerator.get_Current();
using (List <Vector3> .Enumerator enumerator2 = current.get_Value().GetEnumerator())
{
while (enumerator2.MoveNext())
{
Vector3 current2 = enumerator2.get_Current();
list.Add(current2);
}
}
}
}
return(list);
}
public bool MoveToPoint(float x, float z, float range)
{
if (this.owner.IsWeak)
{
return(false);
}
if (!this.ownerActor)
{
return(false);
}
Vector3 terrainPoint = MySceneManager.GetTerrainPoint(x, z, this.ownerActor.FixTransform.get_position().y);
if (XUtility.DistanceNoY(terrainPoint, this.ownerActor.FixTransform.get_position()) > range)
{
this.ownerActor.MoveToPoint(terrainPoint, 0f, null);
}
return(true);
}
public override void OnUpdate()
{
base.OnUpdate();
if (!IsMoving)
{
mDeltaTime += Time.deltaTime;
if (mDeltaTime >= 3f)
{
mIsCoundDown = true;
foreach (Hero hero in mTeammates.Values)
{
if (hero.AttackTarget == null &&
hero.MovingDirection != Vector3.zero &&
XUtility.DistanceNoY(hero.position, transform.position) <= mFollowDist)
{
hero.FollowPoint = hero.position;
hero.StopMoveToPoint();
}
}
}
}
else
{
mIsCoundDown = false;
mDeltaTime = 0;
}
#region 蜂窝站位
if (mDistList != null && !mIsCoundDown)
{
for (int i = 0, len = mDistList.Count; i < len; i++)
{
mDistDict[mDistList[i]].FollowPoint = transform.TransformPoint(BeehiveCell.GetBeehivePos(i));
}
//mCurSpeed = Mathf.Lerp(Attr.MoveSpeed, 0, Mathf.Max(0, mMaxDist - BeehiveCell.CellTier(mTeammates.Count)) / 10f);
}
#endregion
#if UNITY_EDITOR
Debug.DrawRay(transform.position, Vector3.up * 100, Color.red);
#endif
}
private void SortHeroList()
{
mDistDict.Clear();
float index = 0.1f;
float dist;
foreach (Hero hero in mTeammates.Values)
{
dist = XUtility.DistanceNoY(hero.transform.position, transform.position);
if (mDistDict.ContainsKey(dist))
{
dist += index;
index += index;
}
mDistDict.Add(dist, hero);
}
mDistList = new List <float>(mDistDict.Keys);
mDistList.Sort(SortDist);
}
protected bool InRectArea(Vector3 position, float hitRange = 0f)
{
if (position == this.fixBasePoint.position)
{
return(true);
}
Vector3 center = this.Center;
float num = XUtility.DistanceNoY(center, position);
float num2 = Vector2.Angle(new Vector2(position.x - center.x, position.z - center.z), new Vector2(this.forward.x, this.forward.z));
if (num2 > 90f)
{
num2 = 180f - num2;
}
float num3 = Mathf.Abs(Mathf.Sin(num2 * 3.14159274f / 180f) * num);
float num4 = Mathf.Abs(Mathf.Cos(num2 * 3.14159274f / 180f) * num);
return(num3 <= this.width / 2f + hitRange && num4 < this.height / 2f + hitRange);
}
protected void CheckFollowSelf()
{
if (!this.IsSelfExist)
{
return;
}
if (!MySceneManager.Instance.IsSceneExist)
{
return;
}
float num = XUtility.DistanceNoY(this.transform.get_position(), EntityWorld.Instance.EntSelf.Actor.FixTransform.get_position());
if (num <= TaskNPCBehavior.FollowSelfStopDistance)
{
this.StopFollowSelf();
}
else if (num > TaskNPCBehavior.FollowSelfStartDistance)
{
this.FollowSelf();
}
}
public static Vector3 GetBeehivePos(Vector3 pos)
{
Vector3[] points = new Vector3[3];
float unit_x = UnitX(Radius);
float unit_y = UnitY(Radius);
int tierX = Mathf.FloorToInt(pos.x / unit_x);
int tierY = Mathf.FloorToInt(pos.z / unit_y);
points[0].x = unit_x * tierX;
points[1].x = unit_x * (tierX + 0.5f);
points[2].x = unit_x * (tierX + 1);
if (tierY % 2 == 0)
{
points[0].z = points[2].z = unit_y * tierY;
points[1].z = unit_y * (tierY + 1);
}
else
{
points[0].z = points[2].z = unit_y * (tierY + 1);
points[1].z = unit_y * tierY;
}
int index = 0;
float dist, mindist = float.MaxValue;
for (int i = 0; i < 3; i++)
{
dist = XUtility.DistanceNoY(pos, points[i]);
if (dist < mindist)
{
mindist = dist;
index = i;
}
}
return(points[index]);
}
public bool MoveToCurrentBatchPointIgnoreCamp()
{
if (this.owner.IsWeak)
{
return(false);
}
if (!this.ownerActor)
{
return(false);
}
Vector2 zero = Vector2.get_zero();
if (InstanceManager.GetCurrentBattlePathPoint(out zero))
{
if (XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), new Vector3(zero.x, this.ownerActor.FixTransform.get_position().y, zero.y)) > 0.5f)
{
this.ownerActor.MoveToPoint(new Vector3(zero.x, this.ownerActor.FixTransform.get_position().y, zero.y), 0f, null);
}
return(true);
}
return(false);
}
public override void OnUpdate()
{
base.OnUpdate();
if (IsDead)
{
AttackTarget = null;
FollowTarget = null;
return;
}
#region 刷新动作
if (null != FollowTarget)
{
mDeltaTime += Time.deltaTime;
if (mDeltaTime >= 0.2f)
{
mDeltaTime = 0;
SetFloat("runSpeed", XUtility.DistanceNoY(mLastPostion, transform.position));
mLastPostion = transform.position;
}
if (AttackTarget != null && CurSkill.Data.kind == (int)Skill.ESkillKind.Hot)
{
mShotDire = XUtility.DirectionNoY(AttackTarget.transform.position - transform.position);
if (mShotDire.magnitude != 0)
{
Controller.transform.forward = mShotDire.normalized;
mMoveDire = XUtility.DirectionNoY(FollowPoint - transform.position);
Vector3 dire = Controller.transform.InverseTransformDirection(mMoveDire.normalized);
SetFloat("runDirX", dire.x);
SetFloat("runDirZ", dire.z);
}
}
}
#endregion
}
public override bool FindAttackTarget()
{
AttackTarget = null;
Dictionary <long, Hero> hero = GamingSys.Instance.Player.Teammates;
float temp, dire = float.MaxValue;
foreach (Actor actor in hero.Values)
{
if (actor.IsDead || actor.FollowTarget == null)
{
continue;
}
temp = XUtility.DistanceNoY(actor.transform.position, transform.position);
if (temp <= CurSkill.Attr.FindDist && temp < dire)
{
dire = temp;
AttackTarget = actor;
}
}
#if UNITY_EDITOR
XUtility.DrawCircle(transform.position, transform.forward, CurSkill.Attr.FindDist, Color.yellow, 1f);
#endif
return(null != AttackTarget);
}
protected override void UpdateMoveByPointState(float deltaTime)
{
if (base.IsMovePausing)
{
if (!this.IsClearTargetPosition && !this.GetEntity().IsStatic&& !this.GetEntity().IsDizzy&& !this.GetEntity().IsWeak&& (XUtility.StartsWith(this.CurActionStatus, "run") || XUtility.StartsWith(this.CurActionStatus, "idle") || this.GetEntity().IsMoveCast) && base.ToCorner < base.NavMeshPath.get_corners().Length)
{
base.IsMovePausing = false;
base.FixTransform.LookAt(new Vector3(base.NavMeshPath.get_corners()[base.ToCorner].x, base.FixTransform.get_position().y, base.NavMeshPath.get_corners()[base.ToCorner].z));
base.LeftLength = XUtility.DistanceNoY(base.FixTransform.get_position(), base.NavMeshPath.get_corners()[base.ToCorner]);
if (this.CanChangeActionTo("run", true, 0, false))
{
this.ChangeAction("run", false, true, 1f, 0, 0, string.Empty);
}
}
}
else
{
base.CalculateNextPace(deltaTime);
if ((this.CurActionStatus != "run" && this.CurActionStatus != "idle" && !this.GetEntity().IsMoveCast) || this.GetEntity().IsStatic || this.GetEntity().IsDizzy || this.GetEntity().IsWeak)
{
base.IsMovePausing = true;
base.MovingDirection = Vector3.get_zero();
}
else if (XUtility.DistanceNoY(base.FixTransform.get_position(), base.NavMeshPosition) <= 0.05f || base.ToCorner == base.NavMeshPath.get_corners().Length || (base.NextPace >= base.LeftLength && base.ToCorner == base.NavMeshPath.get_corners().Length - 1))
{
if (!this.IsClearTargetPosition)
{
this.IsClearTargetPosition = true;
base.MovingDirection = Vector3.get_zero();
base.FixTransform.set_position(new Vector3(base.NavMeshPosition.x, base.FixTransform.get_position().y, base.NavMeshPosition.z));
TimerHeap.DelTimer(this.stopTimer);
this.stopTimer = TimerHeap.AddTimer(350u, 0, delegate
{
if (this.IsClearTargetPosition && XUtility.StartsWith(this.CurActionStatus, "run"))
{
this.ChangeAction("idle", false, true, 1f, 0, 0, string.Empty);
}
});
}
}
else if (base.NavMeshPath.get_corners().Length > 0 && (XUtility.DistanceNoY(base.FixTransform.get_position(), base.NavMeshPath.get_corners()[base.ToCorner]) <= 0.05f || base.NextPace > base.LeftLength))
{
if (!this.IsClearTargetPosition)
{
base.FixTransform.set_position(new Vector3(base.NavMeshPath.get_corners()[base.ToCorner].x, base.FixTransform.get_position().y, base.NavMeshPath.get_corners()[base.ToCorner].z));
base.ToCorner++;
base.MovingDirection = Vector3.get_zero();
if (base.ToCorner < base.NavMeshPath.get_corners().Length)
{
base.FixTransform.LookAt(new Vector3(base.NavMeshPath.get_corners()[base.ToCorner].x, base.FixTransform.get_position().y, base.NavMeshPath.get_corners()[base.ToCorner].z));
base.LeftLength = XUtility.DistanceNoY(base.FixTransform.get_position(), base.NavMeshPath.get_corners()[base.ToCorner]);
}
}
}
else if (!this.IsClearTargetPosition && (XUtility.StartsWith(this.CurActionStatus, "run") || XUtility.StartsWith(this.CurActionStatus, "idle") || this.GetEntity().IsMoveCast) && base.ToCorner < base.NavMeshPath.get_corners().Length)
{
Vector3 vector = new Vector3(base.NavMeshPath.get_corners()[base.ToCorner].x - base.FixTransform.get_position().x, 0f, base.NavMeshPath.get_corners()[base.ToCorner].z - base.FixTransform.get_position().z);
base.MovingDirection = vector.get_normalized();
base.FixTransform.LookAt(new Vector3(base.NavMeshPath.get_corners()[base.ToCorner].x, base.FixTransform.get_position().y, base.NavMeshPath.get_corners()[base.ToCorner].z));
}
}
}
public bool MoveToFollowTarget(FollowTargetType followTargetType, float searchRange, float startDistance, float stopDistance)
{
if (this.owner.IsWeak)
{
return(false);
}
if (!this.ownerActor)
{
return(false);
}
float hitRadius = XUtility.GetHitRadius(this.ownerActor.FixTransform);
if (this.owner.FollowTarget == null)
{
List <EntityParent> list = new List <EntityParent>();
switch (followTargetType)
{
case FollowTargetType.Self:
list.Add(EntityWorld.Instance.EntSelf);
break;
case FollowTargetType.OtherPlayer:
list.AddRange(EntityWorld.Instance.GetEntities <EntityPlayer>().Values);
break;
case FollowTargetType.Boss:
{
List <EntityParent> values = EntityWorld.Instance.GetEntities <EntityMonster>().Values;
for (int i = 0; i < values.get_Count(); i++)
{
if (values.get_Item(i).IsLogicBoss)
{
list.Add(values.get_Item(i));
}
}
break;
}
}
EntityParent followTarget = null;
float num = 3.40282347E+38f;
for (int j = 0; j < list.get_Count(); j++)
{
if (list.get_Item(j).Actor)
{
if (list.get_Item(j).Actor.FixTransform)
{
float num2 = XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), list.get_Item(j).Actor.FixTransform.get_position()) - hitRadius - XUtility.GetHitRadius(list.get_Item(j).Actor.FixTransform);
if (num2 < searchRange && num2 < num)
{
followTarget = list.get_Item(j);
num = num2;
}
}
}
}
this.owner.FollowTarget = followTarget;
}
if (this.owner.FollowTarget == null)
{
return(false);
}
if (!this.owner.FollowTarget.Actor)
{
this.owner.FollowTarget = null;
return(false);
}
float num3 = XUtility.DistanceNoY(this.ownerActor.FixTransform.get_position(), this.owner.FollowTarget.Actor.FixTransform.get_position()) - hitRadius - XUtility.GetHitRadius(this.owner.FollowTarget.Actor.FixTransform);
if (num3 < stopDistance)
{
this.ownerActor.StopMoveToPoint();
}
else if (num3 > startDistance)
{
this.ownerActor.MoveToPoint(this.owner.FollowTarget.Actor.FixTransform.get_position(), 0f, null);
}
return(true);
}