Hi, I am a new to Unity c# and I am trying to get better at it.
Recently I watched amazing video tutorial: Recreating Mirrors Edge Parkour Movement in Unity Recreating Mirrors Edge Parkour Movement in Unity | Unity Tutorial - YouTube
and I made the same script and player functions, but i noticed that the player camera does not feel so smooth compared to Unity’s PlayerController component. I tried to fix it by myself but I failed.
After I changed Update() to FixedUpdate() and FixedUpdate() to Update(), suddenly turning/camera feels smoother but other functions are not working anymore.
What I have to change in this script to get smoother camera/turning? Thanks for the attention and sorry for my English.
Script:
public class PlayerMovement : MonoBehaviour
{
public enum PlayerStates
{
Grounded,//on the ground
InAir, //in the air
OnWalls, //running on the walls
LedgeGrab, //pulling up a ledge
}
private PlayerCollision Coli;
private Rigidbody Rigid;
private CapsuleCollider Cap;
private Animator Anim;
[Header("Physics")]
public float MaxSpeed; //how fast we run forward
public float BackwardsSpeed; //how fast we run backwards
public float InAirControl; //how much control you have over your movement direction when in air
private float ActSpeed; //how much speed is applied to the rigidbody
public float Acceleration; //how fast we build speed
public float Decceleration; //how fast we slow down
public float DirectionControl = 8; //how much control we have over changing direction
public PlayerStates CurrentState; //the current state the player is in
private float InAirTimer; //how long we are in the air for (this is for use when wall running or falling off the ground
private float OnGroundTimer;
private float AdjustmentAmt; //the amount added to our player acceleration, this is used for adjusting to new speeds such as when we slide
[Header("Turning")]
public float TurnSpeed; //how fast we turn when on the ground
public float TurnSpeedInAir; //how fast we turn when in air
public float TurnSpeedOnWalls; //how fast we turn when on the walls
public float LookUpSpeed; //how fast we look up and down
public Camera Head; //what will function as our players head to tilt up and down (this is a pivot point in our model that the cameras are children of
private float YTurn; //how much we have turned left and right
private float XTurn; //how much we have turned Up or Down
public float MaxLookAngle = 65; //how much we can look up
public float MinLookAngle = -30; //how much we can look down
[Header("Jumping")]
public float JumpHeight; //how high we jump
[Header("Wall Runs")]
public float WallRunTime = 2f; //how long we can run on walls
private float ActWallRunTime = 0; //how long we are actually on a wall
public float TimeBeforeWallRun = 0.2f; //how long we have to be in the air before we can wallrun
public float WallRunUpwardsMovement = 2f; //how much we move up a wall when running on it (make this 0 to just slightly move down a wall we run on
public float WallRunSpeedAcceleration = 2f; //how quickly we build speed to run up walls
[Header("Crouching")]
public float CrouchSpeed = 10; //how fast we move when crouching
public float CrouchHeight = 1.5f; //how tall our capsule will be when crouched
private float StandingHeight = 2f; //this is how tall our capsule is
private bool Crouch;
[Header("Sliding")]
public float SlideAmt; //how far we slide when pressing crouch
public float SlideSpeedLimit; //how fast we have to be traveling before a crouch will trigger a slide
public float SlideControl; //how much we adjust to our slide speed and regain player control
[Header("WallGrabbing")]
public float PullUpTime; //the time it takes to pull onto a ledge
private float ActPullTm; //the actual time it takes to pull up a ledge
private Vector3 OrigPos; //the original Position before grabbing a ledge
private Vector3 LedgePos; //the ledge position to move to
[Header("FOV")]
public float MaxFov;
private float MinFov;
public float FOVSpeed; //how fast we must go before we reach max fov
// Start is called before the first frame update
void Start()
{
Coli = GetComponent<PlayerCollision>();
Rigid = GetComponent<Rigidbody>();
Anim = GetComponentInChildren<Animator>();
MinFov = Head.fieldOfView;
Cap = GetComponent<CapsuleCollider>();
StandingHeight = Cap.height;
AdjustmentAmt = 1;
}
// Update is called once per frame
void Update()
{
float XMove = Input.GetAxis("Horizontal");
float YMove = Input.GetAxis("Vertical");
if (CurrentState == PlayerStates.Grounded)
{
//if we press jump
if (Input.GetButtonDown("Jump"))
{
//jump upwards
JumpUp();
}
}
else if (CurrentState == PlayerStates.InAir)
{
//check for ledge grabs
if (Input.GetButton("Grab"))
{
Vector3 LedgePos = Coli.CheckLedges();
if (LedgePos != Vector3.zero)
{
LedgeGrab(LedgePos);
}
}
//Check if there is a wall to run on
bool Wall = CheckWalls(XMove, YMove);
//we are on the wall
if (Wall)
{
if (InAirTimer > TimeBeforeWallRun)
{
SetOnWall();
return;
}
}
//check for the ground
bool Grounded = Coli.CheckFloor(-transform.up);
//we are on the ground (and have been in the air for a short time, to prevent multiple jump glitched
if (Grounded && InAirTimer > 0.25f)
{
SetOnGround();
}
}
else if (CurrentState == PlayerStates.OnWalls)
{
//check for ledge grabs
if (Input.GetButton("Grab"))
{
Vector3 LedgePos = Coli.CheckLedges();
if (LedgePos != Vector3.zero)
{
LedgeGrab(LedgePos);
}
}
//Check if there is a wall to run on
bool Wall = CheckWalls(XMove, YMove);
//we are no longer on the wall, fall off it
if (!Wall)
{
SetInAir();
return;
}
//check for the ground
bool Grounded = Coli.CheckFloor(-transform.up);
//we are on the ground
if (Grounded)
{
SetOnGround();
}
}
else if(CurrentState == PlayerStates.LedgeGrab)
{
//clamp our rigid velocity to nothing
Rigid.velocity = Vector3.zero;
}
AnimCtrl();
}
void AnimCtrl()
{
int State = 0;
if (CurrentState == PlayerStates.InAir)
State = 1;
else if (CurrentState == PlayerStates.OnWalls)
State = 2;
else if (CurrentState == PlayerStates.LedgeGrab)
State = 3;
Anim.SetInteger("State", State);
Anim.SetBool("Crouching", Crouch);
Vector3 Vel = transform.InverseTransformDirection(Rigid.velocity);
Anim.SetFloat("XVelocity", Vel.x);
Anim.SetFloat("ZVelocity", Vel.z);
Anim.SetFloat("YVelocity", Rigid.velocity.y);
Anim.SetFloat("XInput", Input.GetAxis("Horizontal"));
}
private void FixedUpdate()
{
float Del = Time.deltaTime;
//get our players rotation amount for turning
float CamX = Input.GetAxis("MouseX");
float CamY = Input.GetAxis("MouseY");
//have our player look up and down
LookUpDown(CamY, Del);
//handle our fov
HandleFov(Del);
//get inputs
float horInput = Input.GetAxis("Horizontal");
float verInput = Input.GetAxis("Vertical");
if (CurrentState == PlayerStates.Grounded)
{
//tick our ground timer
if (OnGroundTimer < 10)
OnGroundTimer += Del;
//get magnituded of our inputs
float InputMagnitude = new Vector2(horInput, verInput).normalized.magnitude;
//get the amount of speed, based on if we press forwards or backwards
float TargetSpd = Mathf.Lerp(BackwardsSpeed, MaxSpeed, verInput); //using the vertical input as a lerp from if forward is being pressed
//if we are crouching our target speed is our crouch speed
if (Crouch)
TargetSpd = CrouchSpeed;
LerpSpeed(InputMagnitude, Del, TargetSpd);
MovePlayer(horInput, verInput, Del);
TurnPlayer(CamX, Del, TurnSpeed);
//check for crouching
if(Input.GetButton("Crouching"))
{
//start crouching
if(!Crouch)
{
StartCrouch();
}
}
else
{
//stand up
bool check = Coli.CheckRoof(transform.up);
if (!check)
{
StopCrouching();
}
}
//add to our player adjustment
if (AdjustmentAmt < 1)
AdjustmentAmt += Del * SlideControl;
else
AdjustmentAmt = 1;
//check for the ground
bool Grounded = Coli.CheckFloor(-transform.up);
//we are in the air
if (!Grounded)
{
if (InAirTimer < 0.2f)
InAirTimer += Del;
else
{
SetInAir();
return;
}
}
else
{
//we are on the ground to remove any increase in the air timer
InAirTimer = 0;
}
}
else if(CurrentState == PlayerStates.InAir)
{
//tick our Air timer
if (InAirTimer < 10)
InAirTimer += Del;
MoveInAir(horInput, verInput ,Del);
//turn our player with the in air modifier
TurnPlayer(CamX, Del, TurnSpeedInAir);
}
else if (CurrentState == PlayerStates.OnWalls)
{
//tick our wall run timer
ActWallRunTime += Del;
Debug.Log(ActWallRunTime);
//turn our player with the in air modifier
TurnPlayer(CamX, Del, TurnSpeedOnWalls);
//move our player when on a wall
WallMove(verInput, Del);
}
else if(CurrentState == PlayerStates.LedgeGrab)
{
//tick ledge grab time
ActPullTm += Del;
//pull up the ledge
float PullUpLerp = ActPullTm / PullUpTime;
if (PullUpLerp < 0.5)
{
//lerp our player upwards to the leges y position
float LAmt = PullUpLerp * 2;
transform.position = Vector3.Lerp(OrigPos, new Vector3(OrigPos.x, LedgePos.y, OrigPos.z), LAmt);
}
else if(PullUpLerp <= 1)
{
//set new pull up position
if (OrigPos.y != LedgePos.y)
OrigPos = new Vector3(transform.position.x, LedgePos.y, transform.position.z);
//move to the ledge position
float LAmt = (PullUpLerp - 0.5f) * 2;
transform.position = Vector3.Lerp(OrigPos, LedgePos, PullUpLerp);
}
else
{
//we have finished pulling up!
SetOnGround();
}
}
}
//lerp our current speed to our set max speed, by how much we are pressing the horizontal and vertical input
void LerpSpeed(float InputMag, float D, float TargetSpeed)
{
//multiply our speed by our input amount
float LerpAmt = TargetSpeed * InputMag;
//get our acceleration (if we should speed up or slow down
float Accel = Acceleration;
if (InputMag == 0)
Accel = Decceleration;
//lerp by a factor of our acceleration
ActSpeed = Mathf.Lerp(ActSpeed, LerpAmt, D * Accel);
}
//when in the air or on a wall, we set our action speed to the velocity magnitude, this is so that when we reach the ground again, our speed will carry over our momentum
void SetSpeedToVelocity()
{
float Mag = new Vector2(Rigid.velocity.x, Rigid.velocity.z).magnitude;
ActSpeed = Mag;
}
bool CheckWalls(float X, float Y)
{
if (X == 0 && Y == 0) //if no direction input we are not wall running
return false;
if (ActWallRunTime >= WallRunTime) //if our wall run timer is more than the amount we can run on walls for, we cannot wall run
return false;
//check the collision direction for any walls
float ClampedY = Mathf.Clamp(Y, 0, 1);
Vector3 Dir = transform.forward * ClampedY + transform.right * X;
bool WallCol = Coli.CheckWall(Dir);
return WallCol;
}
void SetInAir()
{
StopCrouching(); //cannot crouch in air
OnGroundTimer = 0; //remove the on ground timer
CurrentState = PlayerStates.InAir;
}
void SetOnGround()
{
//set our current speed to our velocity
SetSpeedToVelocity();
ActWallRunTime = 0; //we are on the ground again, our wall run timer is reset
InAirTimer = 0; //remove the in air timer
CurrentState = PlayerStates.Grounded;
}
void SetOnWall()
{
OnGroundTimer = 0; //remove the on ground timer
InAirTimer = 0; //remove the in air timer
CurrentState = PlayerStates.OnWalls;
}
void LedgeGrab(Vector3 Ledge)
{
//set our ledge position
LedgePos = Ledge;
OrigPos = transform.position;
//reset ledge grab time
ActPullTm = 0;
//remove speed and velocity
Rigid.velocity = Vector3.zero;
ActSpeed = 0;
//start ledge grabs
CurrentState = PlayerStates.LedgeGrab;
}
void StartCrouch()
{
Crouch = true;
Cap.height = CrouchHeight;
if (ActSpeed > SlideSpeedLimit)
SlideSelf();
}
void StopCrouching()
{
Crouch = false;
Cap.height = StandingHeight;
}
void TurnPlayer(float Hor, float D, float turn)
{
//add our inputs to our turn value
YTurn += (Hor * D) * turn;
//turn our character
transform.rotation = Quaternion.Euler(0, YTurn, 0);
}
void LookUpDown(float Ver, float D)
{
//add our inputs to our look angle
XTurn -= (Ver * D) * LookUpSpeed;
XTurn = Mathf.Clamp(XTurn, MinLookAngle, MaxLookAngle);
//look up and down
Head.transform.localRotation = Quaternion.Euler(XTurn, 0, 0);
}
void MovePlayer(float Hor, float Ver, float D)
{
//find the direction to move in, based on the direction inputs
Vector3 MovementDirection = (transform.forward * Ver) + (transform.right * Hor);
MovementDirection = MovementDirection.normalized;
//if we are no longer pressing and input, carryon moving in the last direction we were set to move in
if (Hor == 0 && Ver == 0)
MovementDirection = Rigid.velocity.normalized;
MovementDirection = MovementDirection * ActSpeed;
//apply Gravity and Y velocity to the movement direction
MovementDirection.y = Rigid.velocity.y;
//apply adjustment to acceleration
float Acel = DirectionControl * AdjustmentAmt;
Vector3 LerpVelocity = Vector3.Lerp(Rigid.velocity, MovementDirection, Acel * D);
Rigid.velocity = LerpVelocity;
}
void MoveInAir(float Hor, float Ver, float D)
{
//find the direction to move in, based on the direction inputs
Vector3 MovementDirection = (transform.forward * Ver) + (transform.right * Hor);
MovementDirection = MovementDirection.normalized;
//if we are no longer pressing and input, carryon moving in the last direction we were set to move in
if (Hor == 0 && Ver == 0)
MovementDirection = Rigid.velocity.normalized;
MovementDirection = MovementDirection * ActSpeed;
//apply Gravity and Y velocity to the movement direction
MovementDirection.y = Rigid.velocity.y;
//lerp to our movement direction based on how much airal control we have
Vector3 LerpVelocity = Vector3.Lerp(Rigid.velocity, MovementDirection, InAirControl * D);
Rigid.velocity = LerpVelocity;
}
void WallMove(float Ver, float D)
{
//get the direction to run up this wall if we press forward (keep in mind this only works if the wall is infront or to the side of the player as we run along on, on walls to our immediate right or left we slide down
Vector3 MovementDirection = transform.up * Ver;
MovementDirection = MovementDirection * WallRunUpwardsMovement;
//our x z velocity are our momentum applied to our forward direction
MovementDirection += transform.forward * ActSpeed;
Vector3 LerpVelocity = Vector3.Lerp(Rigid.velocity, MovementDirection, WallRunSpeedAcceleration * D);
Rigid.velocity = LerpVelocity;
}
void JumpUp()
{
//only jump if we are still on the ground
if (CurrentState == PlayerStates.Grounded)
{
//reduce our velocity on the y axis so our jump force can be added
Vector3 VelAmt = Rigid.velocity;
VelAmt.y = 0;
Rigid.velocity = VelAmt;
//add our jump force
Rigid.AddForce(transform.up * JumpHeight, ForceMode.Impulse);
//we are now in the air
SetInAir();
}
}
//increase our fov at high speed and reduce it at low speed
void HandleFov(float D)
{
//get our velocity magniture
float mag = new Vector2(Rigid.velocity.x, Rigid.velocity.z).magnitude;
//get appropritate fov
float LerpAmt = mag / FOVSpeed;
float FieldView = Mathf.Lerp(MinFov, MaxFov, LerpAmt);
//ease into this fov
Head.fieldOfView = Mathf.Lerp(Head.fieldOfView, FieldView, 4 * D);
}
//slide our character forwards
void SlideSelf()
{
//reduce our speed
ActSpeed = SlideSpeedLimit;
//remove any control from player
AdjustmentAmt = 0;
//find direction
Vector3 Dir = Rigid.velocity.normalized;
Dir.y = 0;
//slide in direction
Rigid.AddForce(transform.forward * SlideAmt, ForceMode.Impulse);
}
}