Third-person-controller Jump Air Controls

Unity Engine
1

Hiya. So, this one is a bit different to the code I make myself and I’m using a prefab. Namely the standard Third Person Controller one. Sadly, I cannot find a proper way that gives the player air control (Able to change direction during the jump)

There’s in-air acceleration, but that just accelerates indefinitely and stacks on top of the running speed.

// Require a character controller to be attached to the same game object
@script RequireComponent(CharacterController)

public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;

public var walkMaxAnimationSpeed : float = 0.75;
public var trotMaxAnimationSpeed : float = 1.0;
public var runMaxAnimationSpeed : float = 1.0;
public var jumpAnimationSpeed : float = 1.15;
public var landAnimationSpeed : float = 1.0;

private var _animation : Animation;

enum CharacterState {
    Idle = 0,
    Walking = 1,
    Trotting = 2,
    Running = 3,
    Jumping = 4,
    }

private var _characterState : CharacterState;

// The speed when walking
var walkSpeed = 2.0;
// after trotAfterSeconds of walking we trot with trotSpeed
var trotSpeed = 4.0;
// when pressing "Fire3" button (cmd) we start running
var runSpeed = 6.0;

var inAirControlAcceleration = 3.0;

// How high do we jump when pressing jump and letting go immediately
var jumpHeight = 0.5;

// The gravity for the character
var gravity = 20.0;
// The gravity in controlled descent mode
var speedSmoothing = 10.0;
var rotateSpeed = 500.0;
var trotAfterSeconds = 3.0;

var canJump = true;

private var jumpRepeatTime = 0.05;
private var jumpTimeout = 0.15;
private var groundedTimeout = 0.25;

// The camera doesnt start following the target immediately but waits for a split second to avoid too much waving around.
private var lockCameraTimer = 0.0;

// The current move direction in x-z
private var moveDirection = Vector3.zero;
// The current vertical speed
private var verticalSpeed = 0.0;
// The current x-z move speed
private var moveSpeed = 0.0;

// The last collision flags returned from controller.Move
private var collisionFlags : CollisionFlags;

// Are we jumping? (Initiated with jump button and not grounded yet)
private var jumping = false;
private var jumpingReachedApex = false;

// Are we moving backwards (This locks the camera to not do a 180 degree spin)
private var movingBack = false;
// Is the user pressing any keys?
private var isMoving = false;
// When did the user start walking (Used for going into trot after a while)
private var walkTimeStart = 0.0;
// Last time the jump button was clicked down
private var lastJumpButtonTime = -10.0;
// Last time we performed a jump
private var lastJumpTime = -1.0;


// the height we jumped from (Used to determine for how long to apply extra jump power after jumping.)
private var lastJumpStartHeight = 0.0;


private var inAirVelocity = Vector3.zero;

private var lastGroundedTime = 0.0;


private var isControllable = true;

function Awake ()
{
    moveDirection = transform.TransformDirection(Vector3.forward);
   
    _animation = GetComponent(Animation);
    if(!_animation)
        Debug.Log("The character you would like to control doesn't have animations. Moving her might look weird.");
   
    /*
public var idleAnimation : AnimationClip;
public var walkAnimation : AnimationClip;
public var runAnimation : AnimationClip;
public var jumpPoseAnimation : AnimationClip;   
    */
    if(!idleAnimation) {
        _animation = null;
        Debug.Log("No idle animation found. Turning off animations.");
    }
    if(!walkAnimation) {
        _animation = null;
        Debug.Log("No walk animation found. Turning off animations.");
    }
    if(!runAnimation) {
        _animation = null;
        Debug.Log("No run animation found. Turning off animations.");
    }
    if(!jumpPoseAnimation && canJump) {
        _animation = null;
        Debug.Log("No jump animation found and the character has canJump enabled. Turning off animations.");
    }
           
}


function UpdateSmoothedMovementDirection ()
{
    var cameraTransform = Camera.main.transform;
    var grounded = IsGrounded();
   
    // Forward vector relative to the camera along the x-z plane   
    var forward = cameraTransform.TransformDirection(Vector3.forward);
    forward.y = 0;
    forward = forward.normalized;

    // Right vector relative to the camera
    // Always orthogonal to the forward vector
    var right = Vector3(forward.z, 0, -forward.x);

    var v = Input.GetAxisRaw("Vertical");
    var h = Input.GetAxisRaw("Horizontal");

    // Are we moving backwards or looking backwards
    if (v < -0.2)
        movingBack = true;
    else
        movingBack = false;
   
    var wasMoving = isMoving;
    isMoving = Mathf.Abs (h) > 0.1 || Mathf.Abs (v) > 0.1;
       
    // Target direction relative to the camera
    var targetDirection = h * right + v * forward;
   
    // Grounded controls
    if (grounded)
    {
        // Lock camera for short period when transitioning moving & standing still
        lockCameraTimer += Time.deltaTime;
        if (isMoving != wasMoving)
            lockCameraTimer = 0.0;

        // We store speed and direction seperately,
        // so that when the character stands still we still have a valid forward direction
        // moveDirection is always normalized, and we only update it if there is user input.
        if (targetDirection != Vector3.zero)
        {
            // If we are really slow, just snap to the target direction
            if (moveSpeed < walkSpeed * 0.9 && grounded)
            {
                moveDirection = targetDirection.normalized;
            }
                // Otherwise smoothly turn towards it
            else
            {
                moveDirection = Vector3.RotateTowards(moveDirection, targetDirection, rotateSpeed * Mathf.Deg2Rad * Time.deltaTime, 1000);
               
                moveDirection = moveDirection.normalized;
            }
        }
       
        // Smooth the speed based on the current target direction
        var curSmooth = speedSmoothing * Time.deltaTime;
       
        // Choose target speed
        //* We want to support analog input but make sure you cant walk faster diagonally than just forward or sideways
        var targetSpeed = Mathf.Min(targetDirection.magnitude, 1.0);
   
        _characterState = CharacterState.Idle;
       
        // Pick speed modifier
        if (Input.GetKey (KeyCode.LeftShift) || Input.GetKey (KeyCode.RightShift))
        {
            targetSpeed *= runSpeed;
            _characterState = CharacterState.Running;
        }
        else if (Time.time - trotAfterSeconds > walkTimeStart)
        {
            targetSpeed *= trotSpeed;
            _characterState = CharacterState.Trotting;
        }
        else
        {
            targetSpeed *= walkSpeed;
            _characterState = CharacterState.Walking;
        }
       
        moveSpeed = Mathf.Lerp(moveSpeed, targetSpeed, curSmooth);
       
        // Reset walk time start when we slow down
        if (moveSpeed < walkSpeed * 0.3)
            walkTimeStart = Time.time;
    }
        // In air controls
    else
    {
        // Lock camera while in air
        if (jumping)
            lockCameraTimer = 1.0;

        if (isMoving)
            inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
    }
   

       
}


function ApplyJumping ()
{
    // Prevent jumping too fast after each other
    if (lastJumpTime + jumpRepeatTime > Time.time)
        return;

    if (IsGrounded()) {
        // Jump
        // - Only when pressing the button down
        // - With a timeout so you can press the button slightly before landing       
        if (canJump && Time.time < lastJumpButtonTime + jumpTimeout) {
            verticalSpeed = CalculateJumpVerticalSpeed (jumpHeight);
            SendMessage("DidJump", SendMessageOptions.DontRequireReceiver);
        }
    }
}


function ApplyGravity ()
{
    if (isControllable)    // don't move player at all if not controllable.
    {
        // Apply gravity
        var jumpButton = Input.GetButton("Jump");
       
       
        // When we reach the apex of the jump we send out a message
        if (jumping && !jumpingReachedApex && verticalSpeed <= 0.0)
        {
            jumpingReachedApex = true;
            SendMessage("DidJumpReachApex", SendMessageOptions.DontRequireReceiver);
        }
   
        if (IsGrounded ())
            verticalSpeed = 0.0;
        else
            verticalSpeed -= gravity * Time.deltaTime;
    }
}

function CalculateJumpVerticalSpeed (targetJumpHeight : float)
    {
        // From the jump height and gravity we deduce the upwards speed
        // for the character to reach at the apex.
        return Mathf.Sqrt(2 * targetJumpHeight * gravity);
    }

    function DidJump ()
    {
        jumping = true;
        jumpingReachedApex = false;
        lastJumpTime = Time.time;
        lastJumpStartHeight = transform.position.y;
        lastJumpButtonTime = -10;
   
        _characterState = CharacterState.Jumping;
    }

    function Update() {
   
        if (!isControllable)
        {
            // kill all inputs if not controllable.
            Input.ResetInputAxes();
        }

        if (Input.GetButtonDown ("Jump"))
        {
            lastJumpButtonTime = Time.time;
        }

        UpdateSmoothedMovementDirection();
   
        // Apply gravity
        // - extra power jump modifies gravity
        // - controlledDescent mode modifies gravity
        ApplyGravity ();

        // Apply jumping logic
        ApplyJumping ();
   
        // Calculate actual motion
        var movement = moveDirection * moveSpeed + Vector3 (0, verticalSpeed, 0) + inAirVelocity;
        movement *= Time.deltaTime;
   
        // Move the controller
        var controller : CharacterController = GetComponent(CharacterController);
        collisionFlags = controller.Move(movement);
   
        // ANIMATION sector
        if(_animation) {
            if(_characterState == CharacterState.Jumping)
            {
                if(!jumpingReachedApex) {
                    _animation[jumpPoseAnimation.name].speed = jumpAnimationSpeed;
                    _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
                    _animation.CrossFade(jumpPoseAnimation.name);
                } else {
                    _animation[jumpPoseAnimation.name].speed = -landAnimationSpeed;
                    _animation[jumpPoseAnimation.name].wrapMode = WrapMode.ClampForever;
                    _animation.CrossFade(jumpPoseAnimation.name);               
                }
            }
            else
            {
                if(controller.velocity.sqrMagnitude < 0.1) {
                    _animation.CrossFade(idleAnimation.name);
                }
                else
                {
                    if(_characterState == CharacterState.Running) {
                        _animation[runAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, runMaxAnimationSpeed);
                        _animation.CrossFade(runAnimation.name);   
                    }
                    else if(_characterState == CharacterState.Trotting) {
                        _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, trotMaxAnimationSpeed);
                        _animation.CrossFade(walkAnimation.name);   
                    }
                    else if(_characterState == CharacterState.Walking) {
                        _animation[walkAnimation.name].speed = Mathf.Clamp(controller.velocity.magnitude, 0.0, walkMaxAnimationSpeed);
                        _animation.CrossFade(walkAnimation.name);   
                    }
               
                }
            }
        }
        // ANIMATION sector
   
        // Set rotation to the move direction
        if (IsGrounded())
        {
       
            transform.rotation = Quaternion.LookRotation(moveDirection);
           
        }   
        else
        {
            var xzMove = movement;
            xzMove.y = 0;
            if (xzMove.sqrMagnitude > 0.001)
            {
                transform.rotation = Quaternion.LookRotation(xzMove);
            }
        }   
   
        // We are in jump mode but just became grounded
        if (IsGrounded())
        {
            lastGroundedTime = Time.time;
            inAirVelocity = Vector3.zero;
            if (jumping)
            {
                jumping = false;
                SendMessage("DidLand", SendMessageOptions.DontRequireReceiver);
            }
        }
    }

    function OnControllerColliderHit (hit : ControllerColliderHit )
        {
            //    Debug.DrawRay(hit.point, hit.normal);
            if (hit.moveDirection.y > 0.01)
                return;
        }

        function GetSpeed () {
            return moveSpeed;
        }

        function IsJumping () {
            return jumping;
        }

        function IsGrounded () {
            return (collisionFlags & CollisionFlags.CollidedBelow) != 0;
        }

        function GetDirection () {
            return moveDirection;
        }

        function IsMovingBackwards () {
            return movingBack;
        }

        function GetLockCameraTimer ()
        {
            return lockCameraTimer;
        }

        function IsMoving ()  : boolean
            {
                return Mathf.Abs(Input.GetAxisRaw("Vertical")) + Mathf.Abs(Input.GetAxisRaw("Horizontal")) > 0.5;
            }

            function HasJumpReachedApex ()
            {
                return jumpingReachedApex;
            }

            function IsGroundedWithTimeout ()
            {
                return lastGroundedTime + groundedTimeout > Time.time;
            }

            function Reset ()
            {
                gameObject.tag = "Player";
            }

Just having some control while in the air would really help the game right now.

Thank you for your time. Inform me if I’ve gone out of line or posted anywhere wrong or any such.
Cheers!

2

There are plenty of ways depending on behaviour you want (if Y is up, then should only affect XZ velocity) :

  1. Each frame check if side velocity is larger than limit and decrease it to limit if it is.(accelerate till limit)
  2. Each frame set side velocity directly based on input. (velocity set to limit instantly)
  3. Each frame remove previous side velocity you added from input, add new velocity from input and remember it. (allows saving initial velocity + input modifies velocity temporarily)
3

Thanks for the reply, Teravsior. Sadly, I’m struggling already with this. I want the 3rd options you said, but hmm, I’m unable.

I’d hate to request code as I’m learning, but right now I think I’m approaching it with the wrong logic and simply trying-testing-trying-testing without result.

4

After briefly browsing through your current script, I believe the main problem is that your main movement functionality is done only when your character is grounded, thereby making any control while airborne impossible.

But simply removing the pre-requisite of being grounded is not enough, since you will also be able to jump in mid-air.

What you have to do is discern between what needs to be checked when grounded, and what does not.

Obviously you will have to take out whatever enables you to move and make it independent of being grounded or not. Jump remains needing the pre-requisite of being grounded to be activated. This is the most basic change to make when giving the player control while in air. The rest really is fine-tuning the control to what the player expects.

An example of fine tuning is, players want control while in airborne, but also do not expect to have a lot of control while airborne. You will have to set aside 3 different acceleration speeds:

  • An acceleration for walking.
  • An acceleration for airborne when there is movement input
  • An acceleration for airborne when there is no movement input.
    With the 3 acceleration values setup, you will have to change the acceleration based on the situation. So when grounded, the walking acceleration is used. When airborne, it depends on whether there is movement input or not.
5 
//In body of class
var lastVelocity:Vector2;

//movement:Vector3 is current speed
//inputSpeed:Vector2 is side speed you add from controls this step
//Returns modified speed
function ModifySpeed(movement: Vector3, inputSpeed : Vector2) : Vector3
{
    var sideSpeed = new Vector2(movement.x,movement.z);
    sideSpeed = sideSpeed - lastVelocity + inputSpeed; //Subtract previous velocity and add new one
    lastVelocity = inputSpeed; //Remember input speed for next step
    movement.x = sideSpeed.x;
    movement.z = sideSpeed.y;
    return movement;
}
6

Thank you so much, Teravisor. I was way off. I was attempting to clamp some values.
I’ve been trying to implement this into the code up to now (To save face)

And while I don’t get any errors, I don’t get any results either. Right now the script remains the same, just with your additions added. I am not sure how to proceed.

7

Uhm… I regret now that I didn’t read code much. It’s possible to just cap inAirVelocity now that I’ve read that code a bit better as I’ve prepared ModifySpeed for much simpler use-case.
Replace

if (ifMoving)
    inAirVelocity+=targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;

with

//This code if you want acceleration
if (isMoving)
{
            inAirVelocity += targetDirection.normalized * Time.deltaTime * inAirControlAcceleration;
            var airAdditionalSpeedMaximum = inAirControlAcceleration; //put this variable as global instead and modify as you want. It's maximum speed in air now.
            if(inAirVelocity.magnitude > airAdditionalSpeedMaximum)//Speed limit.
                inAirVelocity = inAirVelocity.normalized*airAdditionalSpeedMaximum;
}

//OR(Not both!) this code if you don't want acceleration in air
if (isMoving)
{
            var airAdditionalSpeedMaximum = inAirControlAcceleration; //put this variable as global instead and modify as you want. It's maximum speed in air now.
            inAirVelocity = targetDirection.normalized * airAdditionalSpeedMaximum;
}

Second: air speed stacks on top of movement speed because var movement = moveDirection * moveSpeed + Vector3(0, verticalSpeed, 0) + inAirVelocity;
One way is to remove moveDirection*moveSpeed part when not in air; remove inAirVelocity instead so it looks like

var movement = Vector3(0, verticalSpeed, 0);
if(IsGrounded())
    movement += moveDirection * moveSpeed;
else
    movement += inAirVelocity;

Note: airAdditionalSpeedMaximum can be merged with moveSpeed if you don’t need separate speed while being in air(just remove var line and use moveSpeed everywhere instead).

8

Bingo! This is working. (Video footage) Thanks for the help. I’m currently undergoing some tutorials and making my own script, but was actually very intimidated by this prefab script. I can see the logic now, only in hindsight after you posted. Thanks! :slight_smile: