Hop (Ketchapp) Mechanic (Jump between platforms with certain velocity while controlling object on X axis)

It's a pretty simple math problem.

You basically want your ball position to do three things:

  * z increases linearly
  * x follows user input
  * y follows a parabola

There are plenty of ways to do that in Unity:

• The first solution would be a rigidbody with gravity enabled, making the physics material drag 0 and bounciness 1, and calculating the vertical velocity of your parabola using a ballistic calculator. The problem is that any error would accumulate, and you would risk missing the platform after a while. You would also have the Unity usual problem of the ball's motion being jerky because the fixed framerate is different than the render framerate.

  • You could also implement a basic physics engine for your ball on Update instead of FixedUpdate, by reducing the y velocity by gravity every frame, and adding the velocity to the position every frame too. This solves the second problem, but not the first.

  • Finally a simple mathematical solution:

     float gameTime = 0f;
       float timeSinceLastBounce = 0f;
      
       public float bounceDistance = 1f;
       public float horizontalVelocity = 2f;
       public float verticalVelocity = 2f;
      
       void Update()
       {
           // We calculate the position
           Vector3 position;
      
           // Your input code, I suggest looking up Mathf.SmoothDamp for smoothing
           //position.x =
      
           // The ball keeps the same horizontal velocity
           position.z = gameTime * horizontalVelocity;
      
           // The time between two bounces
           float bounceDuration = bounceDistance / horizontalVelocity;
           // The time between a bounce an its highest point
           float halfBounceDur = bounceDuration / 2f;
      
           // Gravity needs to cancel completely the verticalVelocity at the highest point of the curve
           // verticalVelocity * halfBounceDur == 0.5 * gravity * halfBounceDur * halfBounceDur
           // therefore
           float halfGravity = verticalVelocity / halfBounceDur;
      
           position.y = verticalVelocity * timeSinceLastBounce - halfGravity * timeSinceLastBounce * timeSinceLastBounce;
      
           transform.localPosition = position;
      
           // We update the time counters
           gameTime += Time.deltaTime;
           timeSinceLastBounce += Time.deltaTime;
      
           // We check if we reached a bounce
           if (timeSinceLastBounce >= bounceDuration)
           {
               // We check if we hit a platform
               if (Physics.Raycast(position, Vector3.down))
               {
                   // Bounce success, play sound?
                   timeSinceLastBounce -= bounceDuration;
               }
               else
               {
                   // Game lost
               }
           }
       }
    
    
    

All math in this code is deduced from the equation newPosition = oldPosition + oldVelocity * time + 0.5 * gravity * time²

Note that bounceDuration, gravity, etc. could be calculated in Start, as they are always the same. However calculating them here allows you to tweak other parameters in-game.

I have not tested this, so be free to tell me if it tell me if it doesn't work. It should though.