HOLD JUMP BUTTON TO JUMP HIGHER

Question

I'm working on a 2D game and I want to give my player a Mario styled jumped, where if the user held the jump button longer the player would jump $$anonymous$$gher and if they held/tap the jump button shorter the player would jump shorter. I followed a tutorial and I was very confused on how I would implement the code into my scripts. I have two scripts, one that handles the physics(CharacterController2D) and the other that handles the input(PlayerMovement).

The tutorial I followed: https://www.youtube.com/watch?v=j111eKN8sJw&t=459s Here is the code from the tutorial:

      private float jumpTimeCounter;
      public float jumpTime;
      private bool isJumping;
  
      void Update()
      {
          if (isGrounded == true && Input.GetKeyDown(KeyCode.Space)) 
          {
              isJumping = true;
              jumpTimeCounter = jumpTime;
              rigidbody2D.velocity = Vector2.up * jumpForce;
          }
  
          if (Input.GetKey(KeyCode.Space) && isJumping == true) 
          {
              if (jumpTimeCounter > 0)
              {
                  rigidbody2D.velocity = Vector2.up * jumpForce;
                  jumpTimeCounter -= Time.deltaTimel
              }
              else 
              {
                  isJumping = false;
              }
          }
  
          if (Input.GetKeyUp(KeyCode.Space)) 
          {
              isJumping = false;
          }
      }

 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 crouc$$anonymous$$ng movement. 1 = 100%
     [Range(0, .3f)] [SerializeField] private float m_MovementSmoot$$anonymous$$ng = .05f;    // How much to smooth out the movement
     [SerializeField] private bool m_AirControl = false;                            // Whether or not a player can steer w$$anonymous$$le 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 crouc$$anonymous$$ng
 
     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 w$$anonymous$$ch 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_wasCrouc$$anonymous$$ng = 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 $$anonymous$$ts anyt$$anonymous$$ng designated as ground
         // T$$anonymous$$s 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 crouc$$anonymous$$ng, check to see if the character can stand up
         if (!crouch)
         {
             // If the character has a ceiling preventing them from standing up, keep them crouc$$anonymous$$ng
             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 crouc$$anonymous$$ng
             if (crouch)
             {
                 if (!m_wasCrouc$$anonymous$$ng)
                 {
                     m_wasCrouc$$anonymous$$ng = true;
                     OnCrouchEvent.Invoke(true);
                 }
 
                 // Reduce the speed by the crouchSpeed multiplier
                 move *= m_CrouchSpeed;
 
                 // Disable one of the colliders when crouc$$anonymous$$ng
                 if (m_CrouchDisableCollider != null)
                     m_CrouchDisableCollider.enabled = false;
             } else
             {
                 // Enable the collider when not crouc$$anonymous$$ng
                 if (m_CrouchDisableCollider != null)
                     m_CrouchDisableCollider.enabled = true;
 
                 if (m_wasCrouc$$anonymous$$ng)
                 {
                     m_wasCrouc$$anonymous$$ng = false;
                     OnCrouchEvent.Invoke(false);
                 }
             }
 
             // Move the character by finding the target velocity
             Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
             // And then smoot$$anonymous$$ng it out and applying it to the character
             m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoot$$anonymous$$ng);
 
             // 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 OnCrouc$$anonymous$$ng(bool isCrouc$$anonymous$$ng) 
     {
         animator.SetBool("IsCrouc$$anonymous$$ng", isCrouc$$anonymous$$ng);
     }
 
     private void FixedUpdate()
     {
         characterController2D.Move(horizontalMove * Time.deltaTime, crouch, jump);
         jump = false; 
     }
 
 }

Answer 1

Hi!

If you don't want re-design your implementation then the workaround can be Coroutine that will be called here in your CharacterController2D:

 // 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));

     StartCoroutine(CheckForSpace());
 }

And the Coroutine itself could look like t$$anonymous$$s:

  float f_AddGravitiy;
 
     IEnumerator CheckForSpace()
     {
         w$$anonymous$$le (!m_Grounded)
         {
             if (!Input.GetKey(KeyCode.Space))
                 m_Rigidbody2D.velocity += Vector2.down * f_AddGravitiy * Time.deltaTime;
             yield return null;
         }
     }

So, basically w$$anonymous$$le m_Grounded is false the Coroutine will check if we are holding KeyCode.Space and if we don't then it will add f_AddGravitiy force to the Rigidbody vertically down. I'm using inverted logic than the tutorial script you attached, but you can change it easily and add vertical positive velocity w$$anonymous$$le holding Space, kinda same t$$anonymous$$ng.

And it will continue do so each frime w$$anonymous$$le m_Grounded is false.

However, the issue will be that when falling down by holding the Space key we will fall slower what makes kinda no sense.

So it's good to check if our vertical velocity is positive, so we won't affect our fall velocity by holding the Space key:

 IEnumerator CheckForSpace()
 {
     w$$anonymous$$le (!m_Grounded)
     {
         if (!Input.GetKey(KeyCode.Space) && m_Rigidbody2D.velocity.y > 0)
             m_Rigidbody2D.velocity += Vector2.down * f_AddGravitiy * Time.deltaTime;
         yield return null;
     }
 }

I hope it helps.

Answer 2

Answer by DevYoung · May 27, 2020 at 01:50 AM

@ADiSiN Hi, it works but it's only works sometimes. Do you have a better method instead of the code from the tutorial.

0 · Share

HOLD JUMP BUTTON TO JUMP HIGHER

2 Replies

Your answer

Welcome to Unity Answers

Follow this Question

Related Questions