Smooth jumping in 2D platformers [duplicate]

Question

I have a very simple 2D game, similar to old-school Mario or Metroid. I'm having a lot of trouble figuring out the proper way to handle player jumping. I've tried several different methods. The first method being that as soon as the player presses the space bar, his position on the Y-Axis is automatically updated so that he is now 50 pixels higher. This didn't work, because his player model immediately jumped up instead of going for that smooth up/down look. The second method I tried was using a Timer. With this, once the player pressed the space bar, his position on the Y-Axis would be incremented every x milliseconds. This also didn't work, for the exact same reason that the first way didn't work. It shot straight up without looking smooth. The last method I tried was a resemblance of my movement on the X-Axis. Instead of waiting for player input, the Y-Axis is constantly being added, but when the player isn't jumping, the yVelocity = 0. When input does come in, an amount is added yVelocity and the player jumps up. I didn't expect this to work, obviously, but it looked better.

So how do you apply jumping correctly? This is something that I've been struggling with for a while, and I just want to get it right. Please don't confuse this question like this question, as they're both different. I need an efficient way to handle jumping so that he looks smooth (as in one motion) going up and down. I can make his falling look good, just not the going up part. Can anybody explain to me how they make jumping look good?

Note: I wrote this question without code because I want a general description of how one might do it. If you do need code or extra details, or anything to understand the question, I'll be happy to add any extra details that you might need.

Answer 1

You should Maintain 3 vectors: Position, Velocity and Acceleration

Initially set acceleration -ve in y-axis to simulate gravity

And Update these vectors at every frame like this

Position += Velocity
Velocity += Acceleration

(But if you are on ground, don't update the y component of velocity and position)

Now when you need to jump, simply set the Y component of Velocity to some +ve value. And you will automatically observe a smooth jump.

What actually happens here, when you set the velocity's Y to positive value, the player starts to rise up in space but since there is also some -ve acceleration, the velocity will also decrease, and at a particular height, velocity will become 0 and starts to drop down. The best part of this approach is that, it gives you a great feel of realistic gravity.

Note: (I am taking down left as (0,0) coordinate)

Answer 2

You must use Y vector applied to coordinate.

Every timer tick Y vector decreases by gravitation, so as higher player jumps as slower it will happens.

i.e. You set vector to 100px/s. This mean that in 1 second player must up to 100px. BUT, gravitation will reduce this height every timer tick. For example it will reduce 100px vector in 1 second. This mean that our vector will be fully decreased in 1 second.

If you have 30 timer ticks for this 1 second, so gravitation will reduce vector by 100/30 every tick.

You must update coordinates every tick by it's vector*time. Time in my example = 1/30s

Trajectory will like parabola in this case. It will be smooth enough.

Answer 3

Consider next values:

Vectors

• pos0: The position of the character when he begin to jump.

• speed0: The speed of the character when he begin to jump.

• pos: current position

• speed: current speed

Values:

• g: gravity.
• t0: time when the character begin to jump.
• t: time elapsed in the current jump.
• speedJump: The momentum added by jumping (vertical) (constant)
• isJumping: if your character is currently jumping

When the player press the space key, your hold the t0 and pos0, and compute speed0:

if (!isJumping) // Only jump if it is not yet currently jumping
{
    t0=currentTime();
    pos0=pos;
    speed0 = speed;
    speed0.y += speedJump;
    isJumping = true;
}

Every frame, you may compute the new position of the character with:

if (isJumping)
{
    t = currentTime()-t0;
    pos.y = pos0.y + speed0.y*t - g*t*t;
    pos.x = pos0.x + speed0.x*t;

    // And test that the character is not on the ground again.
    if (pos.y < groundHeight(pos.x))
    {
        pos.y=groundHeight(pos.x);
        isJumping = false;
    }
}

Answer 4

For this problem, I usually have a preset value for GRAVITY that pulls you down.

public void updatePosition() {
  if (onGround) {
    velocity_y = 0;   //If standing on ground surface, velocity in y-axis is stable.

  } else {
    velocity_y--;
    //Otherwise velocity in y-axis always goes downward, 
    //Depending on which platform you're working on, it could be velocity_y++;

    if (velocity_y < GRAVITY) velocity_y = GRAVITY; 
    // Have a threshold for velocity_y
  }
  // Update the actual position with the velocity calculated.
  x += velocity_x;
  y += velocity_y;
}

The above function is called at every frame

public void jump() {
  velocity_y = 20;
}

And jumping occurs when an event like key press happens.