public void Rotate(Vector3 a_NewUpDirection, RotateMethod a_Method)
{
Vector3 pivot = Vector3.zero;
switch (a_Method)
{
case RotateMethod.FromCenter:
m_UpDirection = a_NewUpDirection;
return;
case RotateMethod.FromBottom:
pivot = GetDownCenter();
break;
case RotateMethod.FromTop:
pivot = GetUpCenter();
break;
}
Vector3 vectorToCenter = m_Position - pivot;
Quaternion rotation = Quaternion.FromToRotation(GetUpDirection(), a_NewUpDirection);
Vector3 targetPosition = pivot + rotation * vectorToCenter;
m_Position = targetPosition;
m_UpDirection = a_NewUpDirection;
if (!m_IsCopy && m_CapsuleCollider != null)
{
m_CapsuleCollider.transform.position = m_Position;
m_CapsuleCollider.transform.rotation = GetRotation();
}
}
//Query whether this module can be active, given the current state of the character controller (velocity, isGrounded etc.)
//Called every frame when inactive (to see if it could be) and when active (to see if it should not be)
public override bool IsApplicable()
{
if (m_ControlledCollider.IsGrounded())
{
return(false);
}
//Wall needs to be hit for the module to be active
if (m_ControlledCollider.GetSideCastInfo().m_HasHitSide)
{
if (!m_ControlledCollider.IsPartiallyTouchingWall())
{
return(false);
}
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
if (!m_ControlledCollider.CanAlignWithNormal(m_UpDirection))
{
return(false);
}
return(true);
}
return(false);
}
//Called for every fixedupdate that this module is active
public override void FixedUpdateModule()
{
if (!m_ControlledCollider.GetSideCastInfo().m_HasHitSide || (!m_ControlledCollider.IsPartiallyTouchingWall()))
{
return;
}
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
float distance = m_ControlledCollider.GetSideCastInfo().GetDistance();
m_ControlledCollider.GetCapsuleTransform().Move(-m_WallNormal * distance);
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
m_ControlledCollider.RotateToAlignWithNormal(m_UpDirection, m_RotateMethod);
Vector2 currentVel = m_ControlledCollider.GetVelocity();
Vector2 fGravity = -m_UpDirection *m_WallRunGravity *Vector2.Dot(-m_UpDirection, Vector2.down); //Gravity along wall, but with correct velocity
Vector2 fDrag = -0.5f * (currentVel.sqrMagnitude) * m_CharacterController.GetDragConstant() * currentVel.normalized;
if (!m_ApplyDrag)
{
fDrag = Vector2.zero;
}
Vector2 summedF = fGravity + fDrag;
Vector2 newVel = currentVel + (summedF * Time.fixedDeltaTime);
m_ControlledCollider.UpdateWithVelocity(newVel);
}
//Reset all state when this module gets initialized
protected override void ResetState()
{
base.ResetState();
m_WallNormal = Vector3.zero;
m_UpDirection = Vector3.zero;
m_RotateMethod = RotateMethod.FromBottom;
}
//Reset all state when this module gets initialized
protected override void ResetState()
{
base.ResetState();
m_WallNormal = Vector3.zero;
m_UpDirection = Vector3.zero;
m_RotateMethod = RotateMethod.FromBottom;
m_IsAlreadyTouchingWall = false;
}
public override void RotateToAlignWithNormal(Vector3 a_Normal, RotateMethod a_Method = RotateMethod.FromBottom)
{
if (m_CapsuleTransform.CanRotate(a_Normal, a_Method))
{
m_CapsuleTransform.Rotate(a_Normal, a_Method);
UpdateContextInfo();
}
}
public ClingyRotationTweener(GameObject gameObject, TweenOptions tweenOptions,
RotateMethod rotateMethod, GetDestinationRotationDelegate GetDestinationRotation,
TweenCompleteDelegate TweenComplete = null, TweenCancelledDelegate TweenCancelled = null)
: base(gameObject, tweenOptions, TweenComplete, TweenCancelled)
{
this.rotateMethod = rotateMethod;
this.GetDestinationRotation = GetDestinationRotation;
}
public void CopyFromPathNode(CapsuleMovementPathNode a_PathNode)
{
m_Position = a_PathNode.m_Position;
m_UpDirection = a_PathNode.m_UpDirection;
m_Length = a_PathNode.m_Length;
m_Duration = a_PathNode.m_Duration;
m_RotateMethod = a_PathNode.m_RotateMethod;
m_ResizeMethod = a_PathNode.m_ResizeMethod;
}
public static Tweener TweenRotation(GameObject gameObject, TweenOptions tweenOptions,
RotateMethod rotateMethod, GetDestinationRotationDelegate GetDestinationRotation,
TweenCompleteDelegate TweenComplete = null, TweenCancelledDelegate TweenCancelled = null)
{
Tweener tweener = new ClingyRotationTweener(gameObject, tweenOptions, rotateMethod,
GetDestinationRotation, TweenComplete, TweenCancelled);
tweener.Start();
return(tweener);
}
//Called for every fixedupdate that this module is active
public override void FixedUpdateModule()
{
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
m_ControlledCollider.RotateToAlignWithNormal(m_UpDirection, m_RotateMethod);
float distance = m_ControlledCollider.GetSideCastInfo().GetDistance();
m_ControlledCollider.GetCapsuleTransform().Move(-m_WallNormal * distance);
m_ControlledCollider.UpdateWithVelocity(Vector2.zero);
}
void Update()
{
if (Input.GetMouseButtonUp(0))
{
if (rotateMethod == RotateMethod.Gyro)
{
rotateMethod = RotateMethod.Compass;
}
else
{
rotateMethod = RotateMethod.Gyro;
}
SetRotateMethod();
}
}
//Called for every fixedupdate that this module is active
public override void FixedUpdateModule()
{
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
m_ControlledCollider.RotateToAlignWithNormal(m_UpDirection, m_RotateMethod);
//if touching a wall during a jump, cut it short when jump is released
if (m_HonorJumpCut)
{
m_CharacterController.UpdateJumpCut();
}
Vector2 currentVel = m_ControlledCollider.GetVelocity();
Vector2 fInput = m_CharacterController.GetDirectedInputMovement() * m_EscapeVelocity;
if (m_WallNormal.y >= 0.1f)
{
fInput = Vector2.zero;
}
float inputDotToNormal = Vector2.Dot(fInput, m_WallNormal);
if (inputDotToNormal <= 0)//Moving into wall, or not moving at all
{
fInput = Vector2.zero;
float distance = m_ControlledCollider.GetSideCastInfo().GetDistance();
m_ControlledCollider.GetCapsuleTransform().Move(-m_WallNormal * distance);
}
Vector2 fGravity = -m_UpDirection * m_SlideGravity;//
if (!m_UseSameGravityForAllSlopes)
{
fGravity *= Vector2.Dot(-m_UpDirection, Vector2.down);//Gravity along wall, but with corrected gravity
}
Vector2 fDrag = -0.5f * (currentVel.sqrMagnitude) * m_CharacterController.GetDragConstant() * currentVel.normalized;
Vector2 summedF = fInput + fGravity + fDrag;
Vector2 newVel = currentVel + (summedF * Time.fixedDeltaTime);
newVel += GetFrictionAlongWall(newVel);
m_ControlledCollider.UpdateWithVelocity(newVel);
}
public bool CanRotate(Vector3 a_NewUpDirection, RotateMethod a_Method)
{
Vector3 pivot = Vector3.zero;
switch (a_Method)
{
case RotateMethod.FromCenter:
pivot = m_Position;
break;
case RotateMethod.FromBottom:
pivot = GetDownCenter();
break;
case RotateMethod.FromTop:
pivot = GetUpCenter();
break;
}
Vector3 vectorToCenter = m_Position - pivot;
Vector3 currentNormal = GetUpDirection();
Quaternion rotation = Quaternion.FromToRotation(currentNormal, a_NewUpDirection);
Vector3 start = Vector3.zero;
Vector3 end = Vector3.zero;
switch (a_Method)
{
case RotateMethod.FromCenter:
start = m_Position - (rotation * vectorToCenter).normalized * m_Length;
end = m_Position + (rotation * vectorToCenter).normalized * m_Length;
break;
case RotateMethod.FromBottom:
start = GetDownCenter();
end = GetDownCenter() + (rotation * vectorToCenter).normalized * m_Length;
break;
case RotateMethod.FromTop:
start = GetUpCenter() + (rotation * vectorToCenter).normalized * m_Length;
end = GetUpCenter();
break;
}
return(!Physics.CheckCapsule(start, end, m_CapsuleCollider.GetRadius() - m_CapsuleCollider.GetRotateCastMargin(), m_CapsuleCollider.GetLayerMask()));
}
//Called for every fixedupdate that this module is active
public override void FixedUpdateModule()
{
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
m_ControlledCollider.RotateToAlignWithNormal(m_UpDirection, m_RotateMethod);
float distance = m_ControlledCollider.GetSideCastInfo().GetDistance();
m_ControlledCollider.GetCapsuleTransform().Move(-m_WallNormal * distance);
Vector2 newVel = Vector2.zero;
if (GetDirInput("Move").m_Direction == DirectionInput.Direction.Down || GetDirInput("Move").m_Direction == DirectionInput.Direction.Up)
{
newVel = m_UpDirection * GetDirInput("Move").m_ClampedInput.y *m_Speed;
}
m_ControlledCollider.UpdateWithVelocity(newVel);
}
//Query whether this module can be active, given the current state of the character controller (velocity, isGrounded etc.)
//Called every frame when inactive (to see if it could be) and when active (to see if it should not be)
public override bool IsApplicable()
{
if (m_ControlledCollider.IsGrounded())
{
return(false);
}
//Wall needs to be hit for the module to be active
if (m_ControlledCollider.GetSideCastInfo().m_HasHitSide)
{
if (m_IsActive)
{
if (!m_ControlledCollider.IsPartiallyTouchingWall())
{
return(false);
}
}
else
{
if (!m_ControlledCollider.IsCompletelyTouchingWall())
{
return(false);
}
}
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
if (!m_ControlledCollider.CanAlignWithNormal(m_UpDirection))
{
return(false);
}
RaycastHit hit;
//If moving down, and possibly entering a position where it cannot rotate back (and therefore escape), stop before this happens
if (Vector3.Dot(m_ControlledCollider.GetVelocity(), m_UpDirection) < 0 && Physics.Raycast(m_ControlledCollider.GetDownCenter(), -m_UpDirection, out hit, m_ControlledCollider.GetRadius() + m_EscapeCornerRaycastDistance, m_ControlledCollider.GetLayerMask()))
{
return(false);
}
return(true);
}
return(false);
}
public static void MoveRotation(Quaternion rotation, Transform transform, RotateMethod rotateMethod,
Rigidbody rb = null, Rigidbody2D rb2D = null)
{
if (rotateMethod == RotateMethod.Translate)
{
transform.rotation = rotation;
}
else if (rotateMethod == RotateMethod.SetPhysics)
{
if (rb)
{
rb.rotation = rotation;
}
else if (rb2D && rb2D.simulated)
{
rb2D.rotation = rotation.eulerAngles.z;
}
else
{
transform.rotation = rotation;
}
}
else if (rotateMethod == RotateMethod.MovePhysics)
{
if (rb)
{
rb.MoveRotation(rotation);
}
else if (rb2D && rb2D.simulated)
{
rb2D.MoveRotation(rotation.eulerAngles.z);
}
else
{
transform.rotation = rotation;
}
}
}
public virtual void RotateToAlignWithNormal(Vector3 a_Normal, RotateMethod a_Method = RotateMethod.FromBottom)
{
}
//Query whether this module can be active, given the current state of the character controller (velocity, isGrounded etc.)
//Called every frame when inactive (to see if it could be) and when active (to see if it should not be)
public override bool IsApplicable()
{
if (m_ControlledCollider.IsGrounded())
{
return(false);
}
//Do allow if we just jumped up
if (m_CharacterController.DidJustJump())
{
m_IsAlreadyTouchingWall = false;
}
if ((DoesInputExist("Crouch") && GetButtonInput("Crouch").m_IsPressed) ||
GetDirInput("Move").m_Direction == DirectionInput.Direction.Down)
{
return(false);
}
//Disable when already touching wall beforehand, except when coming from standing position
if (!m_IsActive && m_AllowOnlyWhenJustTouchingWall && (Time.time - m_CharacterController.GetLastGroundedTime() >= 0.02f))
{
if (m_ControlledCollider.GetSideCastInfo().m_HasHitSide&& (m_ControlledCollider.IsCompletelyTouchingWall()))
{
if (m_IsAlreadyTouchingWall)
{
return(false);
}
m_IsAlreadyTouchingWall = true;
}
else
{
m_IsAlreadyTouchingWall = false;
return(false);
}
}
if (m_ControlledCollider.GetSideCastInfo().m_HasHitSide)
{
if (m_IsActive)
{
if (!m_ControlledCollider.IsPartiallyTouchingWall())
{
return(false);
}
}
else
{
if (!m_ControlledCollider.IsCompletelyTouchingWall())
{
return(false);
}
}
m_WallNormal = m_ControlledCollider.GetSideCastInfo().GetSideNormal();
m_RotateMethod = (m_WallNormal.y < 0) ? RotateMethod.FromTop : RotateMethod.FromBottom;
m_UpDirection = CState.GetDirectionAlongNormal(Vector3.up, m_WallNormal);
float upVelDot = Vector2.Dot(m_UpDirection, m_ControlledCollider.GetVelocity());
if (m_DisableWhenBelowVelocity && upVelDot <= m_MinimumUpVelocityOnStart) //Already going downwards, not applicable
{
return(false);
}
if (!m_ControlledCollider.CanAlignWithNormal(m_UpDirection))
{
return(false);
}
return(true);
}
return(false);
}
public override bool CanAlignWithNormal(Vector3 a_Normal, RotateMethod a_Method = RotateMethod.FromBottom)
{
return(m_CapsuleTransform.CanRotate(a_Normal, a_Method));
}
public virtual bool CanAlignWithNormal(Vector3 a_Normal, RotateMethod a_Method = RotateMethod.FromBottom)
{
return(false);
}
