Variable Jump Height

Question

I'm working on a 2D game and I want to give my player a variable jump height, but don't know how to implement it into my code. I have two scripts, one that handles the physics(CharacterController2D ) and the other that handles the input(PlayerMovement). I feel like my eyes are going to fall out -_-

 using UnityEngine;
 using UnityEngine.Events;
 
 public class CharacterController2D : MonoBehaviour
 {
     [SerializeField] private float m_JumpForce = 400f;                            // Amount of force added when the player jumps.
     [Range(0, 1)] [SerializeField] private float m_CrouchSpeed = .36f;            // Amount of maxSpeed applied to crouching movement. 1 = 100%
     [Range(0, .3f)] [SerializeField] private float m_MovementSmoothing = .05f;    // How much to smooth out the movement
     [SerializeField] private bool m_AirControl = false;                            // Whether or not a player can steer while jumping;
     [SerializeField] private LayerMask m_WhatIsGround;                            // A mask determining what is ground to the character
     [SerializeField] private Transform m_GroundCheck;                            // A position marking where to check if the player is grounded.
     [SerializeField] private Transform m_CeilingCheck;                            // A position marking where to check for ceilings
     [SerializeField] private Collider2D m_CrouchDisableCollider;                // A collider that will be disabled when crouching
 
     const float k_GroundedRadius = .2f; // Radius of the overlap circle to determine if grounded
     private bool m_Grounded;            // Whether or not the player is grounded.
     const float k_CeilingRadius = .2f; // Radius of the overlap circle to determine if the player can stand up
     private Rigidbody2D m_Rigidbody2D;
     private bool m_FacingRight = true;  // For determining which way the player is currently facing.
     private Vector3 m_Velocity = Vector3.zero;
 
     [Header("Events")]
     [Space]
 
     public UnityEvent OnLandEvent;
 
     [System.Serializable]
     public class BoolEvent : UnityEvent<bool> { }
 
     public BoolEvent OnCrouchEvent;
     private bool m_wasCrouching = false;
 
     private void Awake()
     {
         m_Rigidbody2D = GetComponent<Rigidbody2D>();
 
         if (OnLandEvent == null)
             OnLandEvent = new UnityEvent();
 
         if (OnCrouchEvent == null)
             OnCrouchEvent = new BoolEvent();
     }
 
     private void FixedUpdate()
     {
         bool wasGrounded = m_Grounded;
         m_Grounded = false;
 
         // The player is grounded if a circlecast to the groundcheck position hits anything designated as ground
         // This can be done using layers instead but Sample Assets will not overwrite your project settings.
         Collider2D[] colliders = Physics2D.OverlapCircleAll(m_GroundCheck.position, k_GroundedRadius, m_WhatIsGround);
         for (int i = 0; i < colliders.Length; i++)
         {
             if (colliders[i].gameObject != gameObject)
             {
                 m_Grounded = true;
                 if (!wasGrounded)
                     OnLandEvent.Invoke();
             }
         }
     }
 
 
     public void Move(float move, bool crouch, bool jump)
     {
         // If crouching, check to see if the character can stand up
         if (!crouch)
         {
             // If the character has a ceiling preventing them from standing up, keep them crouching
             if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
             {
                 crouch = true;
             }
         }
 
         //only control the player if grounded or airControl is turned on
         if (m_Grounded || m_AirControl)
         {
 
             // If crouching
             if (crouch)
             {
                 if (!m_wasCrouching)
                 {
                     m_wasCrouching = true;
                     OnCrouchEvent.Invoke(true);
                 }
 
                 // Reduce the speed by the crouchSpeed multiplier
                 move *= m_CrouchSpeed;
 
                 // Disable one of the colliders when crouching
                 if (m_CrouchDisableCollider != null)
                     m_CrouchDisableCollider.enabled = false;
             } else
             {
                 // Enable the collider when not crouching
                 if (m_CrouchDisableCollider != null)
                     m_CrouchDisableCollider.enabled = true;
 
                 if (m_wasCrouching)
                 {
                     m_wasCrouching = false;
                     OnCrouchEvent.Invoke(false);
                 }
             }
 
             // Move the character by finding the target velocity
             Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
             // And then smoothing it out and applying it to the character
             m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);
 
             // If the input is moving the player right and the player is facing left...
             if (move > 0 && !m_FacingRight)
             {
                 // ... flip the player.
                 Flip();
             }
             // Otherwise if the input is moving the player left and the player is facing right...
             else if (move < 0 && m_FacingRight)
             {
                 // ... flip the player.
                 Flip();
             }
         }
         // If the player should jump...
         if (m_Grounded && jump)
         {
             // Add a vertical force to the player.
             m_Grounded = false;
             m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
         }
     }
 
 
     private void Flip()
     {
         // Switch the way the player is labelled as facing.
         m_FacingRight = !m_FacingRight;
 
         // Multiply the player's x local scale by -1.
         Vector3 theScale = transform.localScale;
         theScale.x *= -1;
         transform.localScale = theScale;
     }
 }

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class PlayerMovement : MonoBehaviour
 {
 
     public CharacterController2D characterController2D;
 
     public Animator animator; 
 
     public float runSpeed = 40f;
 
     float horizontalMove = 0f;
 
     bool jump = false;
 
     bool crouch = false;
 
     // Start is called before the first frame update
     void Update()
     {
         horizontalMove = Input.GetAxisRaw("Horizontal") * runSpeed;
 
         animator.SetFloat("Speed", Mathf.Abs(horizontalMove));
 
         if (Input.GetButtonDown("Jump")) 
         {
             jump = true;
             animator.SetBool("IsJumping", true);
         }
 
         if (Input.GetButtonDown("Crouch"))
         {
             crouch = true;
         }
         else if (Input.GetButtonUp("Crouch")) 
         {
             crouch = false; 
         }
     }
 
     public void OnLanding() 
     {
         animator.SetBool("IsJumping", false);
     }
 
     public void OnCrouching(bool isCrouching) 
     {
         animator.SetBool("IsCrouching", isCrouching);
     }
 
     private void FixedUpdate()
     {
         characterController2D.Move(horizontalMove * Time.deltaTime, crouch, jump);
         jump = false; 
     }
 
 }

Answer 1

Answer by KoenigX3 · May 26, 2020 at 08:06 AM

Modify the first script like this:

 // Put these two at the declarations
 public float m_minJumpVar = 50;
 public float m_maxJumpVar = 150;
 
 // Replace line 131 with this
 m_RigidBody2D.AddForce(new Vector2(0, m_JumpForce + Random.Range(m_minJumpVar, m_maxJumpVar)));

Note that you can set these variables in the Inspector. You can also make the minimum variable negative. You can also set them private and use [SerializeField] if you want to be able to modify them on runtime.

0 Show 5 · Share

DevYoung · May 26, 2020 at 08:41 AM 0

Share

@KoenigX3 I did exactly as you said and I didn't work, I think it might have something to do with the m_JumpForce.

KoenigX3 DevYoung · May 26, 2020 at 06:54 PM 0

Share

Hmm, that's weird. The code execution process is simple though: your second script calls Move on every FixedUpdate with an occasional jump depending on whether the jump button was pressed. Then your first script receives the jump boolean, and checks m_Grounded. If they are both true, it adds a vertical (y-axis) force to the Rigidbody, with m_JumpForce value. I just added a random force ranging from +50 to +150 to the base 400.

Have you tried changing m_minJumpVar and m_maxJumpVar to a larger value? If it still not working, change your code like this:

 if (m_Grounded && jump)
 {
    // Add a vertical force to the player
    m_Grounded = false;
    Vector2 force = new Vector2(0, m_JumpForce + Random.Range(m_minJumpVar, m_maxJumpVar));
    m_RigidBody2D.AddForce(force);
    Debug.Log(force); // If it causes an error, use force.ToString()
 }

With this you can check whether your script reacted to the random part. If yes, then the only thing left to do is changing the values to larger ones.

DevYoung KoenigX3 · May 26, 2020 at 07:31 PM 0

Share

It doesn't work the way you intended, there is a minimum and maximum jump, but it's very inconsistent... even setting up the values so they work properly is confusing.

Show more comments

Variable Jump Height

1 Reply

Your answer

Welcome to Unity Answers

Follow this Question

Related Questions