Unity input system equivalent of Input.GetKeyDown()

Question

I tried to do it the way I did the others by calling the ReadValue method on moveAction and getting a float but the player just got stuck in the crouching position. What specifically should I change to completely replace crouchKey with crouchAction? Sorry if the script is too large, I included it in its entirety to avoid any possible confusion.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TMPro;
using UnityEngine.InputSystem;

public class PlayerMovement : MonoBehaviour
{
    [Header("Movement")]
    private float moveSpeed;
    public float walkSpeed;
    public float sprintSpeed;

    public float groundDrag;

    [Header("Jumping")]
    public float jumpForce;
    public float jumpCooldown;
    public float airMultiplier;
    bool readyToJump;

    [Header("Crouching")]
    public float crouchSpeed;
    public float crouchYScale;
    private float startYScale;

    [Header("Keybinds")]
    public KeyCode crouchKey = KeyCode.LeftControl;

    [Header("Ground Check")]
    public float playerHeight;
    public LayerMask whatIsGround;
    bool grounded;

    [Header("Slope Handling")]
    public float maxSlopeAngle;
    private RaycastHit slopeHit;
    private bool exitingSlope;

    public Transform orientation;

    float horizontalInput;
    float verticalInput;

    Vector3 moveDirection;

    Rigidbody rb;

    PlayerInput playerInput;
    InputAction moveAction;
    InputAction jumpAction;
    InputAction sprintAction;
    InputAction crouchAction;

    public MovementState state;
    public enum MovementState
    {
        walking,
        sprinting,
        crouching,
        air
    }

    private void Start()
    {
        rb = GetComponent<Rigidbody>();
        playerInput = GetComponent<PlayerInput>();
        moveAction = playerInput.actions["move"];
        jumpAction = playerInput.actions["jump"];
        sprintAction = playerInput.actions["sprint"];
        crouchAction = playerInput.actions["crouch"];

        rb.freezeRotation = true;

        readyToJump = true;

        startYScale = transform.localScale.y;
    }

    private void Update()
    {
        grounded = Physics.Raycast(transform.position, Vector3.down, playerHeight * 0.5f + 0.2f, whatIsGround);

        MyInput();
        SpeedControl();
        StateHandler();

        if (grounded)
            rb.drag = groundDrag;
        else
            rb.drag = 0;
    }

    private void FixedUpdate()
    {
        MovePlayer();
    }

    private void MyInput()
    {
        var jumpInput = jumpAction.ReadValue<float>();
        var crouchInput = crouchAction.ReadValue<float>();

        if(jumpInput > 0 && readyToJump && grounded)
        {
            readyToJump = false;

            Jump();

            Invoke(nameof(ResetJump), jumpCooldown);
        }

        if (Input.GetKeyDown(crouchKey))
        {
            transform.localScale = new Vector3(transform.localScale.x, crouchYScale, transform.localScale.z);
            rb.AddForce(Vector3.down * 5f, ForceMode.Impulse);
        }

        if (Input.GetKeyUp(crouchKey))
        {
            transform.localScale = new Vector3(transform.localScale.x, startYScale, transform.localScale.z);
        }
    }

    private void StateHandler()
    {
        var sprintInput = sprintAction.ReadValue<float>();
        var crouchInput = crouchAction.ReadValue<float>();

        if (Input.GetKey(crouchKey))
        {
            state = MovementState.crouching;
            moveSpeed = crouchSpeed;
        }

        else if(grounded && sprintInput > 0)
        {
            state = MovementState.sprinting;
            moveSpeed = sprintSpeed;
        }

        else if (grounded)
        {
            state = MovementState.walking;
            moveSpeed = walkSpeed;
        }

        else
        {
            state = MovementState.air;
        }
    }

    private void MovePlayer()
    {
        var moveInput = moveAction.ReadValue<Vector2>();

        moveDirection = orientation.forward * moveInput.y + orientation.right * moveInput.x;

        if (OnSlope() && !exitingSlope)
        {
            rb.AddForce(GetSlopeMoveDirection() * moveSpeed * 20f, ForceMode.Force);

            if (rb.velocity.y > 0)
                rb.AddForce(Vector3.down * 80f, ForceMode.Force);
        }

        else if(grounded)
            rb.AddForce(moveDirection.normalized * moveSpeed * 10f, ForceMode.Force);

        else if(!grounded)
            rb.AddForce(moveDirection.normalized * moveSpeed * 10f * airMultiplier, ForceMode.Force);

        rb.useGravity = !OnSlope();
    }

    private void SpeedControl()
    {
        if (OnSlope() && !exitingSlope)
        {
            if (rb.velocity.magnitude > moveSpeed)
                rb.velocity = rb.velocity.normalized * moveSpeed;
        }

        else
        {
            Vector3 flatVel = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

            if (flatVel.magnitude > moveSpeed)
            {
                Vector3 limitedVel = flatVel.normalized * moveSpeed;
                rb.velocity = new Vector3(limitedVel.x, rb.velocity.y, limitedVel.z);
            }
        }
    }

    private void Jump()
    {
        exitingSlope = true;

        rb.velocity = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

        rb.AddForce(transform.up * jumpForce, ForceMode.Impulse);
    }
    private void ResetJump()
    {
        readyToJump = true;

        exitingSlope = false;
    }

    private bool OnSlope()
    {
        if(Physics.Raycast(transform.position, Vector3.down, out slopeHit, playerHeight * 0.5f + 0.3f))
        {
            float angle = Vector3.Angle(Vector3.up, slopeHit.normal);
            return angle < maxSlopeAngle && angle != 0;
        }

        return false;
    }

    private Vector3 GetSlopeMoveDirection()
    {
        return Vector3.ProjectOnPlane(moveDirection, slopeHit.normal).normalized;
    }
}

Have a look at wasPressedThisFrame

KYL3R
– KYL3R

2023-01-02 13:50:09 +00:00
Commented Jan 2, 2023 at 13:50 — KYL3R
– KYL3R, Commented Jan 2, 2023 at 13:50

Nicolas · Accepted Answer · 2023-01-02 14:43:13Z

If you want to continue polling for input you can use something along the lines of if(Keyboard.current.spaceKey.wasPressedThisFrame) inside your Update loop.

You can also create a ActionMap (highly recommended) and bind to created actions rather direct keystrokes. Refer to this for further information.

We do something like this (!only works when Generate C# Class is activated on the InputAction Asset!):

public class PlayerController : MonoBehaviour
{
    //Replace YourInput with your InputMap name.
    private YourInput _inputMap;

    private void Awake()
    {
        _inputMap = new YourInput();
        RegisterInputEvents();
        _inputMap.Player.Enable();
    }
    private void OnDestroy()
    {
        UnregisterInputEvents();
    }
        
    private void RegisterInputEvents()
    {
        _inputMap.Player.SomeAction.performed += OnLeftHookInput;
        //...//
    }
    /// <summary>
    /// Deregisters functions of all input events
    /// </summary>
    private void UnregisterInputEvents()
    {
        if (_inputMap == null) return;
        _inputMap.Player.SomeAction.performed -= OnLeftHookInput;
        //...//
    }

    private void OnLeftHookInput(InputAction.CallbackContext actionContext)
    {
        //we need this for some reason...
        if (!actionContext.performed) return;
        //Do Stuff
    }
}

Just in case you need it, getting a Vector2 from the input would be something like this:

private void OnMousePositionInput(InputAction.CallbackContext actionContext)
{
    if (!actionContext.performed) return;
    _mousePosition = actionContext.ReadValue<Vector2>();
}

Collectives™ on Stack Overflow

Unity input system equivalent of Input.GetKeyDown()

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related