6.3 — Jump Feel: Fall Speed & Coyote Time

Compare against your own file rather than copying it. Three things have to match and nothing else does: the fall multiplier is written on the physics clock and restored on the way up, the jump is gated by two windows rather than by the ground check alone, and both windows are spent the instant the jump fires. Your launch, your ground check, your names and all four of your numbers are yours.

// ------------------------------------------------------------------
//  REFERENCE FILE — Assets/Scripts/PlayerController.cs
//  Written to be read, not pasted. Build it with the walkthrough
//  above, one step at a time, then open this and compare.
//  If it is sitting in your project unchanged, that is the thing
//  to go and do now — the walkthrough is still above you.
// ------------------------------------------------------------------
using UnityEngine;

// PlayerController.cs — the jump, and the four numbers that make it feel like
// yours. Movement 1.4, animation 1.6, the velocity rule 2.2, the launch from
// 6.1, the ground check from 6.2 — and the two mercies.
public class PlayerController : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private float jumpForce = 7f;          // yours already — 6.1's step 1

    // ---- the four numbers this lesson is about --------------------------
    [SerializeField] private float fallMultiplier = 2.5f;   // heavier going down
    [SerializeField] private float riseCut = 0.5f;          // release shortens the rise
    [SerializeField] private float coyoteTime = 0.1f;       // grace after the ledge
    [SerializeField] private float jumpBufferTime = 0.12f;  // grace before the floor

    // ---- your 6.2 check, unchanged. This file writes the raycast row; if you
    // picked a different one, CheckGround() is the only place that changes. ---
    [SerializeField] private float groundDistance = 0.6f;
    [SerializeField] private LayerMask groundMask;

    private Rigidbody2D body;
    private float baseGravity;          // read once, so the Inspector still owns it

    private bool isGrounded;
    private float lastGroundedTime;     // a MOMENT, not a count
    private float lastJumpPressedTime;  // the other moment, a different field

    void Start()
    {
        body = GetComponent<Rigidbody2D>();

        // ... your 6.1 gravity line, if you wrote one for the scene ...
        baseGravity = body.gravityScale;    // read it LAST — after your 6.1 gravity line above
    }

    void Update()
    {
        // ... your input, movement and animation from 1.4, 1.6 and 2.2 ...
        CheckGround();

        // The memory: refreshed on every frame the feet are down.
        if (isGrounded)
        {
            lastGroundedTime = Time.time;
        }

        // The other memory: written by the key, on the frame it goes down.
        if (Input.GetKeyDown(KeyCode.Space))
        {
            lastJumpPressedTime = Time.time;
        }

        // The same subtraction twice, asked in opposite directions.
        bool stillInGrace = Time.time - lastGroundedTime <= coyoteTime;
        bool pressedRecently = Time.time - lastJumpPressedTime <= jumpBufferTime;

        if (pressedRecently && (isGrounded || stillInGrace))
        {
            Jump();
        }

        // The fourth number: let go early and the rise is cut short.
        if (Input.GetKeyUp(KeyCode.Space) && body.linearVelocity.y > 0f)
        {
            body.linearVelocity = new Vector2(body.linearVelocity.x, body.linearVelocity.y * riseCut);
        }
    }

    // Gravity is a value the physics engine reads, so it is written on the
    // physics clock: fifty times a second here, whatever the frame rate is.
    void FixedUpdate()
    {
        if (body.linearVelocity.y < 0f)
        {
            body.gravityScale = baseGravity * fallMultiplier;
        }
        else
        {
            body.gravityScale = baseGravity;
        }
    }

    private void Jump()
    {
        // Your launch from 6.1: one flick. Writing linearVelocity directly
        // works identically here — the Kinematic MovePosition row does not,
        // because a Kinematic body has no gravity for the fall branch to fight.
        body.AddForce(Vector2.up * jumpForce, ForceMode2D.Impulse);

        // Spend both windows. A window that is never closed is a jetpack —
        // and unlike the turret's cooldown, this one cannot close itself.
        lastGroundedTime = -999f;
        lastJumpPressedTime = -999f;
    }

    private void CheckGround()
    {
        // A RaycastHit2D is true when the ray hit something and false when it
        // did not, so it stores straight into the bool. Your 6.2 technique,
        // whichever of the four you chose, belongs on this line.
        isGrounded = Physics2D.Raycast(transform.position, Vector2.down, groundDistance, groundMask);
    }
}