I am trying to make a variable jump height mechanic work on a 2d platformer

I am working on a 2d platformer and we are using 2 scripts for player movement. We have a character controller handling most of the variables and some mechanics happening to the player and we have a player movement script handling most of the inputs. All tutorials I can find I could not get the variable jump height to work with the way we set it up. I also have a double jump mechanic that might be making it not work, but I can not figure out why or how. Here is the script i tried to get working with it but can not get.

 [SerializeField] public float m_JumpForce = 150f;                          // Amount of force added when the player jumps.
     [SerializeField] public float m_JumpShortForce = 75f;                     // Amount of force to apply to cut the  player jump.
     // [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 LayerMask m_WhatIsWall;
     [SerializeField] private Transform m_GroundCheck;                           // A position marking where to check if the player is grounded.
     [SerializeField] private Transform m_WallCheck;
     /* [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
     public bool m_FacingRight = true;                                 // For determining which way the player is currently facing.
     const float k_WalledRadius = .02f;
     const float k_GroundedRadius = .02f; // Radius of the overlap circle to determine if grounded
     public bool m_Grounded;                     // Whether or not the player is grounded.
     bool m_Walled;
     // const float k_CeilingRadius = .2f;   // Radius of the overlap circle to determine if the player can stand up
     private Rigidbody2D m_Rigidbody2D;
     private Vector3 m_Velocity = Vector3.zero;
     private bool flippedRight = true;
     bool stuckRight = false;
     bool stuckLeft = false;
     bool canDoubleJump = false;
 
     [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;
 
         if (!m_FacingRight && flippedRight)
         {
             FlipLeft();
         }
 
         if (m_FacingRight && !flippedRight)
         {
             FlipRight();
         }
 
         //WALL STICKING STARTS HERE
         bool wasWalled = m_Walled;
         m_Walled = false;
 
         Collider2D[] wallColliders = Physics2D.OverlapCircleAll(m_WallCheck.position, k_WalledRadius, m_WhatIsWall);
         for (int i = 0; i < wallColliders.Length; i++)
         {
             if (wallColliders[i].gameObject != gameObject)
             {
                 m_Walled = true;
             }
         }
         //WALL STICKING ENDS HERE
 
         // 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 jump, bool jumpCancel)
     {
         //WALL STICKING STARTS HERE
         if (!m_Grounded && m_Walled)
         {
             if (move > 0)
             {
                 m_Rigidbody2D.constraints = RigidbodyConstraints2D.FreezeAll;
                 stuckRight = true;
             }
 
             if (move < 0)
             {
                 m_Rigidbody2D.constraints = RigidbodyConstraints2D.FreezeAll;
                 stuckLeft = true;
             }
         }
 
         if (stuckRight && move <= 0)
         {
             if (move <= 0)
             {
                 m_Walled = false;
                 stuckRight = false;
                 m_Rigidbody2D.constraints = RigidbodyConstraints2D.None;
                 m_Rigidbody2D.constraints = RigidbodyConstraints2D.FreezeRotation;
             }
         }
 
         if (stuckLeft && move >= 0)
         {
             m_Walled = false;
             stuckLeft = false;
             m_Rigidbody2D.constraints = RigidbodyConstraints2D.None;
             m_Rigidbody2D.constraints = RigidbodyConstraints2D.FreezeRotation;
         }
         //WALL STICKING ENDS HERE
         //only control the player if grounded or airControl is turned on
         if (m_Grounded || m_AirControl)
         {
 
            
             // 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 player should jump...
         if (m_Grounded && jump)
         {
             // Add a vertical force to the player.
             jump = false;
             m_Grounded = false;
             canDoubleJump = true;
             m_Rigidbody2D.velocity = new Vector2(m_Rigidbody2D.velocity.x, 0f);
             m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
         }
 
         //Variable Jump Height
         if (m_Grounded && jumpCancel)
         {
             if(m_Rigidbody2D.velocity.y > m_JumpShortForce)
             {
                 m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpShortForce));
             }
             jumpCancel = false;
             
         }
 
         //Double Jumping
         else if (canDoubleJump && jump)
             {
                 canDoubleJump = false;
             m_Rigidbody2D.velocity = new Vector2(m_Rigidbody2D.velocity.x, 0f);
             m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
             }
     }
 
 
     private void FlipRight()
     {
         transform.Rotate(0f, -180f, 0);
         flippedRight = true;
     }
 
     private void FlipLeft()
     {
         transform.Rotate(0f, 180f, 0);
         flippedRight = false;
     }
 
     public void Bounce()
     {
         m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
     }

and the player movement script

 [SerializeField] CharacterController characterController;
     [SerializeField] GravityController gravityController;
     [SerializeField] float walkSpeed = 5f;
     [SerializeField] float runSpeed = 7.5f;
 
     float horizontalMove = 0f;
     bool jump = false;
     bool jumpCancel = false;
     bool isRunning = false;
     bool gravityReversed = false;
 

 
     //wall hanging variables
     private Rigidbody2D rb;
 
     private void Start()
     {
         rb = gameObject.GetComponent<Rigidbody2D>();
     }
 
     // Update is called once per frame
     void Update()
     {
         //CheckSurroundings();
         //CheckIfWallSliding();
         
         if (Input.GetButtonDown("Fire3"))
         {
             isRunning = true;
         }
 
         if (Input.GetButtonUp("Fire3"))
         {
             isRunning = false;
         }
 
         if (!isRunning)
         {
             horizontalMove = Input.GetAxisRaw("Horizontal") * walkSpeed;
         }
         else
         {
             horizontalMove = Input.GetAxisRaw("Horizontal") * runSpeed;
         }
 
         if (Input.GetButtonDown("Jump"))
         {
             jump = true;
         }
 
         if (Input.GetButtonUp("Jump"))
         {
             jumpCancel = true;
         }
 
         if (Input.GetKeyDown(KeyCode.V))
         {
             if (characterController.m_Grounded == true)
             {
                 gravityReversed = !gravityReversed;
                 characterController.m_JumpForce *= -1;
 
                 if (gravityReversed)
                 {
                     gravityController.ReverseGravity(true);
                 }
                 else
                 {
                     gravityController.ReverseGravity(false);
                 }
             }
         }
 
         //activates wallsliding
         /*if(isWallSliding)
         {
             if(rb.velocity.y < -wallSlideSpeed)
             {
                 rb.velocity = new Vector2(rb.velocity.x, -wallSlideSpeed);
             }
         }*/
     }
 
     void FixedUpdate()
     {
         characterController.Move(horizontalMove * Time.fixedDeltaTime, jump, jumpCancel);
         jump = false;
         jumpCancel = false;
     }