protected override void UF_OnPlay(GameObject tar, Vector3 tarPos, Vector3 vecforward)
{
base.UF_OnPlay(tar, tarPos, vecforward);
m_SinForward = MathX.UF_DegForward(m_Forward, -90);
m_DegRateTick = 0;
m_OffsetRateTick = 0;
}
protected override void UF_OnPlay(GameObject tar, Vector3 tarPos, Vector3 vecforward)
{
if (speed <= 0.01f)
{
Debugger.UF_Error("Speed is too samll,play failed!");
m_IsPlaying = false;
return;
}
vecforward.y = 0;
m_Forward = vecforward.normalized;
float len = Vector3.Distance(tarPos, this.position);
tarPos = len * m_Forward + this.position;
m_TarPosition = tarPos + tarOffset * m_Forward;
if (inGround) m_TarPosition.y = 0;
m_SorPosition = this.position;
m_Distance = Vector3.Distance(tarPos, this.position);
m_Duration = m_Distance / speed;
m_DurationTick = 0;
lastPosition = this.position;
//设置角度指向
this.euler = new Vector3(0, MathX.UF_EulerAngle(this.position, tarPos).y, 0);
EffectControl.UF_ResetTailRender(this.gameObject);
}
protected void UF_UpdateMoveBack(float dtime)
{
if (!m_isMovingBack)
{
return;
}
if (m_MoveBackDuration <= 0.0001f || ower == null)
{
this.UF_Stop();
return;
}
else
{
m_MoveBackDurationTick += dtime;
float progress = Mathf.Clamp01(m_MoveBackDurationTick / m_MoveBackDuration);
Vector3 pos = m_MoveBackSorPositon * (1 - progress) + ower.transform.position * progress;
this.position = pos;
//设置角度指向
this.euler = new Vector3(0, MathX.UF_EulerAngle(this.position, ower.transform.position).y, 0);
if (progress >= 1)
{
this.UF_Stop();
}
}
}
protected override void UF_OnPlay(GameObject tar, Vector3 tarPos, Vector3 vecforward)
{
if (speed <= 0.01f)
{
Debugger.UF_Error("Speed is too samll,play failed!");
this.UF_Stop();
return;
}
if (m_Target == null)
{
this.UF_Stop();
return;
}
m_TimeTick = 0;
m_SourcePos = this.position;
//计算出总时间
float distance = Vector3.Distance(m_SourcePos, tar.transform.position);
m_Duration = distance / speed;
//设置角度指向
this.euler = new Vector3(0, MathX.UF_EulerAngle(vecforward).y, 0);
//偏移幅度
m_trackOffset.x = offset.x * (Random.Range(1, 100) - 50.0f) / 50.0f;
m_trackOffset.y = offset.y * (Random.Range(1, 50)) / 50.0f;
m_Target = tar;
m_CurTargetPos = m_Target.transform.position;
EffectControl.UF_ResetTailRender(this.gameObject);
}
public void TurnForward(Vector3 forward)
{
if (!isActive)
{
return;
}
UF_TurnTo(MathX.UF_EulerAngle(forward).y);
}
protected override void UF_OnPlay(GameObject tar, Vector3 tarPos, Vector3 vecforward)
{
//this.transform.eulerAngles = MathX.UF_EulerAngle(vecforward);
//设置角度指向
if (fixEulerOnPlay)
{
this.euler = new Vector3(0, MathX.UF_EulerAngle(vecforward).y, 0);
}
}
protected override void UF_OnStart()
{
if (spaceWorld && worldForwardMode)
{
//重新计算
Vector3 fvEuler = MathX.UF_EulerAngle(this.transform.forward);
m_Source += fvEuler;
m_Target += fvEuler;
}
}
private void UpdateInput()
{
if (maskGraphicTrigger && DeviceInput.UF_Press(0))
{
if (uiCamera == null)
{
return;
}
//停止复位
m_IsResumePoint = false;
if (!m_IsPress)
{
m_SourceDragPos = DeviceInput.UF_DownPosition(0);
joyRoot.gameObject.transform.position = uiCamera.ScreenToWorldPoint(m_SourceDragPos);
m_IsPress = true;
UF_CallDelegateEvent(m_EventJoyPressDown);
UF_CallUnityEvent(m_UEventPressDown);
}
if (m_IsPress)
{
m_TargetDragPos = DeviceInput.UF_PressPosition(0);
float dist = Vector3.Distance(m_SourceDragPos, m_TargetDragPos);
float limitV = limtPointDistance * Screen.width / UIManager.FixedWidth;
if (dist > limitV)
{
m_TargetDragPos = m_SourceDragPos + (m_TargetDragPos - m_SourceDragPos).normalized * limitV;
}
if (joyPoint != null)
{
joyPoint.gameObject.transform.position = uiCamera.ScreenToWorldPoint(m_TargetDragPos);
}
// float angle = 0;
Vector3 _moveVector = MathX.UF_Foward(m_SourceDragPos, m_TargetDragPos);
if (dist > deadZoom)
{
m_MoveForward = new Vector3(_moveVector.x, gravity, _moveVector.y).normalized;
UF_CallDelegateEvent(m_EventJoyPressMove);
UF_UpdateRotate(m_MoveForward);
}
}
}
else
{
if (m_IsPress)
{
m_IsPress = false;
UF_ResumePoint(); UF_UpdateRevertRoot();
UF_CallDelegateEvent(m_EventJoyPressUp);
UF_CallUnityEvent(m_UEventPressUp);
}
}
}
public void UF_TurnTo(float angle)
{
if (!isActive)
{
return;
}
//计算动态旋转速度
float angleClamp = MathX.UF_ClampNormalAngle(m_TurnAngle, angle);
m_TurnAngle = angle;
isTurning = true;
}
private void UF_UpdateMove()
{
if (!isMoving || lockMove)
{
return;
}
if (MathX.UF_DistanceSquare(m_Avatar.position, m_DirectionPoint) > m_DistanceBounds)
{
//重新计算路径点移动向量
m_MoveForward = (m_DirectionPoint - m_Avatar.position).normalized;
UF_MoveAvatarPostion(m_MoveForward * speedMove * GTime.RunDeltaTime);
//判断是否已经超过目标点了
if (Vector3.Dot(m_MoveForward, m_DirectionPoint - m_Avatar.position) < 0)
{
m_Avatar.position = m_DirectionPoint;
}
}
else
{
if (m_ListPathPoints.Count > 0)
{
m_LastDirectionPoint = m_DirectionPoint;
m_DirectionPoint = m_ListPathPoints[0];
//计算路径点移动向量
m_MoveForward = (m_DirectionPoint - m_Avatar.position).normalized;
if (!lockMoveTurn)
{
UF_TurnTo(m_DirectionPoint);
}
m_ListPathPoints.RemoveAt(0);
//派发路径点变动事件
UF_InvokePathPointChange(m_DirectionPoint);
//直接执行一次，不需等待下一帧
UF_UpdateMove();
}
else
{
isMoving = false;
m_FollowOffset = 0.3f;
//派发路径点变动事件
UF_InvokePathPointChange(m_Avatar.position);
UF_InvokePathPointFinish();
}
}
// 更新状态
if (mLastMoveSate != isMoving)
{
//移动状态变更
mLastMoveSate = isMoving;
UF_InvokeMoveStateChange(mLastMoveSate);
}
}
//处理网格
public void OnPopulateMesh()
{
float hfwidth = width / 2;
mesh.Clear();
s_ListTempUV.Clear();
s_ListTempVert.Clear();
s_ListTempIndex.Clear();
if (m_Positions.Count < 1)
{
return;
}
for (int k = 0; k < m_Positions.Count - 1; k++)
{
var pointA = m_Positions[k];
var pointB = m_Positions[k + 1];
if (useWorldSpace)
{
pointA = pointA - this.transform.position;
pointB = pointB - this.transform.position;
}
var forward = (pointB - pointA).normalized * hfwidth;
Vector3 p1 = MathX.UF_RotateForward(forward, -90) + pointA;
Vector3 p2 = MathX.UF_RotateForward(forward, -90) + pointB;
Vector3 p3 = MathX.UF_RotateForward(forward, 90) + pointB;
Vector3 p4 = MathX.UF_RotateForward(forward, 90) + pointA;
//加入顶点
s_ListTempVert.Add(p1);
s_ListTempVert.Add(p2);
s_ListTempVert.Add(p3);
s_ListTempVert.Add(p4);
//加入UV
s_ListTempUV.Add(new Vector2(1, 0));
s_ListTempUV.Add(new Vector2(0, 0));
s_ListTempUV.Add(new Vector2(0, 1));
s_ListTempUV.Add(new Vector2(1, 1));
//加入顶点索引
//0,2,1,0,3,2
s_ListTempIndex.Add(3 + k * 4);
s_ListTempIndex.Add(0 + k * 4);
s_ListTempIndex.Add(2 + k * 4);
s_ListTempIndex.Add(2 + k * 4);
s_ListTempIndex.Add(0 + k * 4);
s_ListTempIndex.Add(1 + k * 4);
}
mesh.vertices = s_ListTempVert.ToArray();
mesh.uv = s_ListTempUV.ToArray();
mesh.triangles = s_ListTempIndex.ToArray();
meshFilter.mesh = mesh;
}
public void UF_TurnTo(Vector3 point)
{
if (!isActive)
{
return;
}
if (m_Avatar == null)
{
Debugger.UF_Warn("m_TransAvatar is null TurnToPoint Fial");
return;
}
UF_TurnTo(MathX.UF_EulerAngle(m_Avatar.position, point).y);
}
private void UF_UpdateRotate(Vector3 forward)
{
if (rotateRange)
{
var vAngle = MathX.UF_EulerAngle(forward);
if (joyRange != null)
{
var e = joyRange.transform.localEulerAngles;
e.z = -vAngle.y;
joyRange.transform.localEulerAngles = e;
}
}
}
protected override void UF_UpdateMoveForward(float dtime)
{
lastPosition = this.position;
float offsetVal = offset;
if (offsetRate > 0)
{
m_OffsetRateTick += dtime * offsetRate;
offsetVal = Mathf.Min(m_OffsetRateTick, offset);
}
m_DegRateTick += degRate * dtime;
Vector3 offsetPos = m_SinForward * (Mathf.Sin(m_DegRateTick)) * offsetVal;
this.position += speed * m_Forward * dtime + offsetPos * dtime;
this.euler = MathX.UF_EulerAngle(lastPosition, this.position);
}
protected override void UF_OnPlay(GameObject tar, Vector3 tarPos, Vector3 vecforward)
{
if (speed <= 0.01f)
{
Debugger.UF_Error("Speed is too samll,play failed!");
m_IsPlaying = false;
return;
}
tarPos.y = this.position.y;
useReboundTimes = 0;
lastPosition = this.position;
//设置角度指向
this.euler = new Vector3(0, MathX.UF_EulerAngle(vecforward).y, 0);
EffectControl.UF_ResetTailRender(this.gameObject);
}
//碰撞
internal void UF_OnCollisionHit(ControllerColliderHit hit)
{
if (!activeTriggerCollision)
{
return;
}
GameObject hitTarget = hit.gameObject;
if (hitTarget.tag == DefineTag.Ground)
{
return;
}
if (!UF_CheckCollisionIntervalTime())
{
return;
}
//忽略指定层碰撞
if (hitTarget.tag == DefineTag.Block || hitTarget.tag == DefineTag.Unwalk)
{
//碰撞不可走区域
MessageSystem.UF_GetInstance().UF_Send(DefineEvent.E_AVATAR_BLOCK, m_Avatar, hitTarget, hit.point);
return;
}
//只处理角色间碰撞
if (m_Avatar.tag != hitTarget.tag)
{
//if (!CheckCollisionIntervalTime()) return;
if (GHelper.UF_CheckStringMask(collisionMask, hitTarget.tag))
{
//推开角色
if (hit.collider is CharacterController)
{
var targetController = hit.collider as CharacterController;
Vector3 pushForward = MathX.UF_Foward(m_Avatar.position, hit.transform.position);
pushForward.y = 0;
//Vector3 pushForward = hit.moveDirection;
targetController.Move(pushFactor * pushForward.normalized * GTime.RunDeltaTime);
}
MessageSystem.UF_GetInstance().UF_Send(DefineEvent.E_AVATAR_COLLISION, m_Avatar, hitTarget);
}
}
}
protected IEnumerator UF_MotionTransPosition(
Transform target,
Vector3 vfrom,
Transform toObj,
float duration,
bool ingoreTimeScale,
float heightOffset,
bool spaceWorld,
Vector3 offset,
bool focusAngle,
DelegateVoid eventFinish)
{
float progress = 0;
float tickBuff = 0;
while (progress < 1)
{
float delta = ingoreTimeScale ? GTime.RunDeltaTime : GTime.UnscaleDeltaTime;
tickBuff += delta;
progress = Mathf.Clamp01(tickBuff / duration);
Vector3 current = progress * (toObj.position + offset) + (1 - progress) * vfrom;
Vector3 currentOffset = new Vector3(0, heightOffset * Mathf.Sin(Mathf.PI * progress), 0);
Vector3 lastPositon = default(Vector3);
if (spaceWorld)
{
lastPositon = target.position;
target.position = current + currentOffset;
if (focusAngle)
{
target.eulerAngles = MathX.UF_EulerAngle(lastPositon, target.position);
}
}
else
{
lastPositon = target.localPosition;
target.localPosition = current + currentOffset;
if (focusAngle)
{
target.localEulerAngles = MathX.UF_EulerAngle(lastPositon, target.position);
}
}
yield return(null);
}
GHelper.UF_SafeCallDelegate(eventFinish);
}
protected void UF_UpdateRebound(float dtime)
{
if (m_isRebounding)
{
m_isRebounding = false;
useReboundTimes++;
Vector3 normal = UF_GetNormalFormBlock(m_hitTargetPos, lastPosition, m_Forward);
//求得反射方向
m_Forward = m_Forward - 2 * Vector3.Dot(normal, m_Forward) * normal;
m_Forward.y = 0;
m_Forward = m_Forward.normalized;
//设置角度指向
this.euler = new Vector3(0, MathX.UF_EulerAngle(m_Forward).y, 0);
//更新一次Forward避免异常碰撞
UF_UpdateMoveForward(dtime);
}
}
private void UF_UpdateTurn()
{
if (!isTurning || lockTurn)
{
return;
}
if (Mathf.Abs(m_Avatar.transModel.eulerAngles.y - m_TurnAngle) > m_ClampAngleBounds)
{
float _angle = Mathf.SmoothDampAngle(m_Avatar.transModel.eulerAngles.y, m_TurnAngle, ref m_VelocityTurnAngle, speedTurn);
m_Forward = MathX.UF_DegForward(Vector3.forward, _angle);
m_Avatar.transModel.eulerAngles = new Vector3(m_Avatar.transModel.eulerAngles.x, _angle, m_Avatar.transModel.eulerAngles.z);
}
else
{
isTurning = false;
m_VelocityTurnAngle = 0;
}
}
private void UF_UpdateFollowMotion()
{
if (m_FollowTarget != null)
{
if (!m_FollowTarget.activeSelf)
{
m_FollowTarget = null;
return;
}
float bounds = m_Avatar.capsule.radius * 0.5f;
Vector3 tpos = m_FollowTarget.transform.position;
if (MathX.UF_Distance(tpos, m_Avatar.position) > (followBounds + bounds + m_FollowOffset))
{
m_FollowOffset = 0;
Vector3 targetPoint = tpos + (m_Avatar.position - tpos).normalized * (bounds + followBounds);
isMoving = false;
UF_AddPathPoint(targetPoint, null);
}
}
}
protected override void UF_OnRun(float dtime)
{
float progress = 0;
m_TimeTick += dtime;
if (m_Duration > 0)
{
progress = Mathf.Clamp01(m_TimeTick / m_Duration);
}
if (m_Target != null)
{
Vector3 tarpos = m_Target.transform.position;
if (!m_Target.activeSelf)
{
tarpos = m_CurTargetPos;
}
tarpos.y = m_SourcePos.y;
Vector3 current = progress * (tarpos) + (1 - progress) * m_SourcePos;
float sinVal = Mathf.Sin(Mathf.PI * progress);
Vector3 currentOffset = new Vector3(m_trackOffset.x * sinVal, m_trackOffset.y * sinVal, 0);
m_LastPos = this.position;
m_CurTargetPos = m_Target.transform.position;
this.position = current + currentOffset;
if (focusAngle)
{
this.euler = MathX.UF_EulerAngle(m_LastPos, this.position);
}
if ((progress) >= 1f)
{
//this.Stop();
UF_OnColliderEnter(m_Target, this.position);
}
}
else
{
this.UF_Stop();
}
}
private void UF_updateFollow()
{
if (m_Target != null)
{
Vector3 targetpos = m_Target.position;
// Vector3 camerapos = mTransMainCam.position;
// if (!m_bFirstSet)
// {
// updaePlace();
// m_bFirstSet = true;
// return;
// }
// 判断，如果对象的位置没有改变才调用此方法
// if (!MathX.VectorEquals(m_LastTargetPos,targetpos) || !MathX.VectorEquals(mLastCameraPos,camerapos))
if (!MathX.UF_VectorEquals(m_LastTargetPos, targetpos))
{
UF_updaePlace();
// mLastCameraPos = camerapos;
m_LastTargetPos = targetpos;
}
// updaePlace();
}
}
protected virtual void UF_OnPlay(GameObject tar, Vector3 tarPos, Vector3 vecforward)
{
//设置角度指向
this.euler = new Vector3(0, MathX.UF_EulerAngle(vecforward).y, 0);
}
private void UF_UpdateCamera(float smoothVal)
{
if (!mTarget || !mActiveTarget)
{
mWorldPoint = UF_GetWorldPoint(this.transform.position);
}
else
{
Vector3 current = this.transform.position;
Vector3 target = mTarget.transform.position + targetOffset;
Vector3 dpos = target;
if (smoothVal <= 0)
{
dpos = target;
}
else
{
dpos = MathX.UF_SmoothDamp3(current, target, ref mVel, smoothVal);
}
if (lockAixsHorizontal)
{
dpos.x = current.x;
}
if (lockAixsVertical)
{
dpos.z = current.z;
}
desirePos = dpos;
mWorldPoint = UF_GetWorldPoint(desirePos);
}
hfRealCamWidth = ViewWidth * 0.5f;
realCamHight = (ViewHight / Mathf.Sin(Mathf.Deg2Rad * slope));
hfRealCamHight = realCamHight * 0.5f;
cornerA = new Vector3(mWorldPoint.x + hfRealCamWidth, mWorldPoint.y, mWorldPoint.z - hfRealCamHight);
cornerB = new Vector3(mWorldPoint.x - hfRealCamWidth, mWorldPoint.y, mWorldPoint.z - hfRealCamHight);
cornerC = new Vector3(mWorldPoint.x - hfRealCamWidth, mWorldPoint.y, mWorldPoint.z + hfRealCamHight);
cornerD = new Vector3(mWorldPoint.x + hfRealCamWidth, mWorldPoint.y, mWorldPoint.z + hfRealCamHight);
cornerUp = new Vector3((cornerA.x + cornerB.x) / 2.0f, mWorldPoint.y, cornerA.z);
cornerDown = new Vector3((cornerC.x + cornerD.x) / 2.0f, mWorldPoint.y, cornerC.z);
//得到4个角点
if (isCheckBorder)
{
Vector3 tempDesirePos = desirePos;
if (!lockAixsHorizontal)
{
if (cornerA.x > boardRange.width)
{
tempDesirePos.x = boardRange.width - hfRealCamWidth;
}
else if (cornerB.x < boardRange.x)
{
tempDesirePos.x = boardRange.x + hfRealCamWidth;
}
}
if (!lockAixsVertical)
{
if (cornerD.z > boardRange.height)
{
tempDesirePos.z = boardRange.height - hfRealCamHight;
}
else if (cornerA.z < boardRange.y)
{
tempDesirePos.z = boardRange.y + hfRealCamHight;
}
}
desirePos = tempDesirePos;
}
}
protected IEnumerator UF_MotionPathPoint(
Transform target,
List <Vector3> pathPoints,
float duration,
bool ingoreTimeScale,
float heightOffset,
bool spaceWorld,
Vector3 offset,
bool focusAngle,
DelegateVoid eventFinish)
{
if (pathPoints.Count == 1)
{
target.position = pathPoints[0];
yield break;
}
//计算总长度
float totalLenght = 0;
for (int k = 1; k < pathPoints.Count; k++)
{
totalLenght += Vector3.Distance(pathPoints[k - 1], pathPoints[k]);
}
if (totalLenght <= 0)
{
target.position = pathPoints[pathPoints.Count - 1];
yield break;
}
for (int k = 1; k < pathPoints.Count; k++)
{
float progress = 0;
float tickBuff = 0;
Vector3 vfrom = pathPoints[k];
Vector3 vto = pathPoints[k - 1];
//计算每段的时间片段
float unitDuration = Vector3.Distance(vfrom, vto) / totalLenght;
if (unitDuration <= 0)
{
continue;
}
while (progress < 1)
{
float delta = ingoreTimeScale ? GTime.RunDeltaTime : GTime.UnscaleDeltaTime;
tickBuff += delta;
progress = Mathf.Clamp01(tickBuff / duration);
Vector3 current = progress * (vto + offset) + (1 - progress) * vfrom;
Vector3 currentOffset = new Vector3(0, heightOffset * Mathf.Sin(Mathf.PI * progress), 0);
Vector3 lastPositon = default(Vector3);
if (spaceWorld)
{
lastPositon = target.position;
target.position = current + currentOffset;
if (focusAngle)
{
target.eulerAngles = MathX.UF_EulerAngle(lastPositon, target.position);
}
}
else
{
lastPositon = target.localPosition;
target.localPosition = current + currentOffset;
if (focusAngle)
{
target.localEulerAngles = MathX.UF_EulerAngle(lastPositon, target.position);
}
}
yield return(null);
}
}
GHelper.UF_SafeCallDelegate(eventFinish);
}
