title: I have some serious problems with new Input System
body: <p>I'm making a 2D platformer game with Unity and It's been 3 weeks since I decided to use the new Input System for gamepad and keyboard support and I'm still struggling with it. Also, I'm using Player Input component and invoke unity events behavior. In fact, I downloaded a Player Controller code from GitHub to use it as a guide and I copied and pasted it to my actual player controller, but the problem is that it's using the old Input System. So I need to change the code a little bit but I don't know how to write the equivalent code in void update instead of <code>(Input.GetAxisRaw(&quot;Horizontal&quot;))</code>. I've been trying to solve this for a long time and I would appreciate if you could guide me.</p>
  <p>This is my Player Controller code:</p>
  <pre><code>using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  using UnityEngine.InputSystem;
  
  public class PlayerController : MonoBehaviour
  {
      private PlayerInputActions controls;
  
      private Rigidbody2D rb;
      private Animator anim;
      private bool facingRight = true;
      private float moveInput;
      public Transform feetPos;
      public float jumpInput;
      public float speed;
  
      [SerializeField] float JumpVelocity = 5;
      float JumpPressedRemember = 0;
      [SerializeField] float JumpPressedRememberTime = 0.2f;
  
      float GroundedRemember = 0;
  
      [SerializeField] float GroundedRememberTime = 0.25f;
      [SerializeField] float HorizontalAcceleration = 1;
      [SerializeField] [Range(0, 1)] float HorizontalDampingBasic = 0.5f;
      [SerializeField] [Range(0, 1)] float HorizontalDampingWhenStopping = 0.5f;
      [SerializeField] [Range(0, 1)] float HorizontalDampingWhenTurning = 0.5f;
      [SerializeField] [Range(0, 1)] float JumpHeight = 0.5f;
  
      private void Awake()
      {
          controls = new PlayerInputActions();
      }
  
      void Start()
      {
          rb = GetComponent&lt;Rigidbody2D&gt;();
          anim = GetComponent&lt;Animator&gt;();
      }
  
      public void OnMove(InputAction.CallbackContext context)
      {
          moveInput = context.ReadValue&lt;float&gt;();
      }
  
      public void OnJump(InputAction.CallbackContext context)
      {
          JumpVelocity = context.ReadValue&lt;float&gt;();
      }
  
      void FixedUpdate()
      {
          rb.velocity = new Vector2(moveInput * speed, rb.velocity.y);
        
          if (facingRight == false &amp;&amp; moveInput &gt; 0)
          {
              Flip();
          }
          else if (facingRight == true &amp;&amp; moveInput &lt; 0)
          {
  
              Flip();
          }
      }
  
      void Flip()
      {
          facingRight = !facingRight;
          Vector3 Scaler = transform.localScale;
          Scaler.x *= -1;
          transform.localScale = Scaler;
      }
  
      void Update()
      {
          Vector2 GroundedBoxCheckPosition = (Vector2)transform.position + new Vector2(0, -0.01f);
          Vector2 GroundedBoxCheckScale = (Vector2)transform.localScale + new Vector2(-0.02f, 0);
          bool Grounded = Physics2D.OverlapBox(GroundedBoxCheckPosition, transform.localScale, 0);
  
          GroundedRemember -= Time.deltaTime;
  
          if (Grounded)
          {
              GroundedRemember = GroundedRememberTime;
          }
  
          JumpPressedRemember -= Time.deltaTime;
  
          if (controls.Player.Jump.triggered)
          {
              JumpPressedRemember = JumpPressedRememberTime;
          }
  
          if (controls.Player.Jump.triggered)
          {
              if (rb.velocity.y &gt; 0)
              {
                  rb.velocity = new Vector2(rb.velocity.x, rb.velocity.y * JumpHeight);
              }
          }
  
          if ((JumpPressedRemember &gt; 0) &amp;&amp; (GroundedRemember &gt; 0))
          {
              JumpPressedRemember = 0;
              GroundedRemember = 0;
              rb.velocity = new Vector2(rb.velocity.x, JumpVelocity);
          }
  
          float HorizontalVelocity = rb.velocity.x;
          HorizontalVelocity += Input.GetAxisRaw(&quot;Horizontal&quot;);
  
          if (Mathf.Abs(Input.GetAxisRaw(&quot;Horizontal&quot;)) &lt; 0.01f)
              HorizontalVelocity *= Mathf.Pow(1f - HorizontalDampingWhenStopping, Time.deltaTime * 10f);
          else if (Mathf.Sign(Input.GetAxisRaw(&quot;Horizontal&quot;)) != Mathf.Sign(HorizontalVelocity))
              HorizontalVelocity *= Mathf.Pow(1f - HorizontalDampingWhenTurning, Time.deltaTime * 10f);
          else
              HorizontalVelocity *= Mathf.Pow(1f - HorizontalDampingBasic, Time.deltaTime * 10f);
  
          rb.velocity = new Vector2(HorizontalVelocity, rb.velocity.y);
      }
  }
  </code></pre>
  <p>And this is the code that I downloaded from GitHub.</p>
  <pre><code>using System.Collections;
  using System.Collections.Generic;
  using UnityEngine;
  
  public class PlayerMovement : MonoBehaviour
  {
  [SerializeField]
  LayerMask lmWalls;
  
  [SerializeField]
  float fJumpVelocity = 5;
  
  Rigidbody2D rigid;
  
  float fJumpPressedRemember = 0;
  [SerializeField]
  float fJumpPressedRememberTime = 0.2f;
  
  float fGroundedRemember = 0;
  [SerializeField]
  float fGroundedRememberTime = 0.25f;
  
  [SerializeField]
  float fHorizontalAcceleration = 1;
  [SerializeField]
  [Range(0, 1)]
  float fHorizontalDampingBasic = 0.5f;
  [SerializeField]
  [Range(0, 1)]
  float fHorizontalDampingWhenStopping = 0.5f;
  [SerializeField]
  [Range(0, 1)]
  float fHorizontalDampingWhenTurning = 0.5f;
  
  [SerializeField]
  [Range(0, 1)]
  float fCutJumpHeight = 0.5f;
  
  void Start ()
  {
      rigid = GetComponent&lt;Rigidbody2D&gt;();
  }
  
  void Update ()
  {
      Vector2 v2GroundedBoxCheckPosition = (Vector2)transform.position + new Vector2(0, -0.01f);
      Vector2 v2GroundedBoxCheckScale = (Vector2)transform.localScale + new Vector2(-0.02f, 0);
      bool bGrounded = Physics2D.OverlapBox(v2GroundedBoxCheckPosition, v2GroundedBoxCheckScale, 0, lmWalls);
  
      fGroundedRemember -= Time.deltaTime;
      if (bGrounded)
      {
          fGroundedRemember = fGroundedRememberTime;
      }
  
      fJumpPressedRemember -= Time.deltaTime;
      if (Input.GetButtonDown(&quot;Jump&quot;))
      {
          fJumpPressedRemember = fJumpPressedRememberTime;
      }
  
      if (Input.GetButtonUp(&quot;Jump&quot;))
      {
          if (rigid.velocity.y &gt; 0)
          {
              rigid.velocity = new Vector2(rigid.velocity.x, rigid.velocity.y * fCutJumpHeight);
          }
      }
  
      if ((fJumpPressedRemember &gt; 0) &amp;&amp; (fGroundedRemember &gt; 0))
      {
          fJumpPressedRemember = 0;
          fGroundedRemember = 0;
          rigid.velocity = new Vector2(rigid.velocity.x, fJumpVelocity);
      }
  
      float fHorizontalVelocity = rigid.velocity.x;
      fHorizontalVelocity += Input.GetAxisRaw(&quot;Horizontal&quot;);
  
      if (Mathf.Abs(Input.GetAxisRaw(&quot;Horizontal&quot;)) &lt; 0.01f)
          fHorizontalVelocity *= Mathf.Pow(1f - fHorizontalDampingWhenStopping, Time.deltaTime * 10f);
      else if (Mathf.Sign(Input.GetAxisRaw(&quot;Horizontal&quot;)) != Mathf.Sign(fHorizontalVelocity))
          fHorizontalVelocity *= Mathf.Pow(1f - fHorizontalDampingWhenTurning, Time.deltaTime * 10f);
      else
          fHorizontalVelocity *= Mathf.Pow(1f - fHorizontalDampingBasic, Time.deltaTime * 10f);
  
      rigid.velocity = new Vector2(fHorizontalVelocity, rigid.velocity.y);
  }
  }
  </code></pre>