Jumping character goes through slope

Newbie & Debugging Questions
#1

Hello dear JGO forumers,

 I've spent the last 2 days working on slope/hills for my 2D plateformer game. I got the slope working and you can move up and down on it, but when the player starts jumping onto the slope he goes through it. I'm just wondering if this http://jnrdev.72dpiarmy.com/en/jnrdev2/ is the only way to implement slope that doesn't cause the jump bug or is it possible for the method I came up with.

This is my check slope method and it’s only called when player is moving left/right or jumping

/** Check if there's a slope and shift Y according to it */
	private void checkSlope(float x, float y) {
		/** If there is a slope in the next x direction do slope movement */
		if(map.onSlope(x + sizeW / 2 , y + sizeH)) {
			if(jumpDistance > 0 && jumping) {
				py = (int)y + 1;
			}
			onSlope = true;
			jumping = false;
			/** Moving to right slope */
			if(map.slopeTyle(x + sizeW / 2 , y + sizeH) == Map.SLOPE_R) {
				if(left) {
					moveY(-moveSpeed);
				} else {
					moveY(moveSpeed);
				}
			/** Moving to left slope */
			} else {
				if(right) {
					moveY(-moveSpeed);
				} else {
					moveY(moveSpeed);
				}
			}
		/** moving from a plateform down to the slope */
		} else if(map.onSlope(x + sizeW / 2, y  + 1) && !jumping) {
			onSlope = true;
			moveY(moveSpeed);
		} else {
			onSlope = false;
		}
	}
#2

There are other ways, although this is the easiest. Typically you’d keep him from going through the slope by checking the total Y displacement you would be doing. If it’s too large (more than half his height or something like that), then that means that he can’t actually go through it and so should be repelled normally. This also makes sense for if you’re trying to walk into a wall. Normally this method will place you all the way on top of the wall.

#3

Thanks for the reply Demonpants! That gave me some ideas on how to fix up the slope problem, I’ll go try it out now ;D

#4

Hi JGO members,

This is my updated checkSlope code using Y displacement check like demonpants suggested, I can walk up and down, jump around the slope just fine now. But when I’m moving from higher tile onto a slope, “sometimes” the character will keep jumping if i don’t press any key. I’m suspecting its because I didn’t fully check when the player is entering a slope. So I added this if statement before my check slope method, but it only made things worse(player jumps more often now), any help would be appreciated.

New If statement I added to check if there’s a slope going down near left/right of player

if(map.onSlope(checkX, checkY + sizeH) ) {
		jumping = false;
		onSlope = true;
		moveY(moveSpeed);
	}

My new slope method that works with moving left/right/jumping, but with the minor bug I posted. The player’s checkbox for slope checking is at buttom center of the player rectangle.

/** Check if there's a slope and shift Y according to it */
	private void checkSlope(float x, float y) {
		/** X used for slope check */
		float checkX = x + sizeW / 2;
		/** Y used for slope check */
		float checkY = y + sizeH;
		
		if(map.onSlope(checkX, checkY) && !(jumpDistance < 0)) {
			onSlope = true;
			jumping = false;
			idle = false;
			/** Center X of player - Tile X */
			float xpos = checkX - (int)checkX;
			if(map.slopeStyle(checkX, checkY) == Map.SLOPE_L) {
				/**Left Slope: Tile Y - xpos */
				py = (int)checkY - xpos;
			} else {
				/** Right Slope: Tile Y - xpos */
				py = (int)checkY - (1 - xpos);
			}
		} else {
			onSlope = false;
		}
	}
#5

I’m having trouble understanding what your problem is.

By “moving from a higher tile onto a slope,” do you mean a tile that is at a Y of 15, dropping down to a slope at a Y of 12, or something like that?

By “keep jumping if I don’t press any key,” what do you mean exactly? Like when you have no buttons pressed they continue to go up and down as if you were tapping the jump button? Or they stay in the air? Or what?

It sounds like it’s the bouncing thing, which doesn’t seem like it makes sense to have as a problem. Usually you have a bool to check to see if you can currently jump at all, set to true if a block is below the player’s feet, otherwise to false. Then you only jump if a jump button is being held down. I don’t understand why your guy would continue jumping unless a button was being held down…

#6

Sorry that I didn’t phrase my problems clearly. For the first question, its the way you understand it, moving from a tile that is at Y of 15 to a slope at Y of 12.

For the second question the “keep jumping” is when no buttons are pressed the character continues to go up(shifted up Y by the checkSlope method) and down(falling down).

I also have a boolean to check if the player is onSlope or not, when onSlope is true the character cannot fall( when player is falling, I’m also calling the jump method but instead of going up, he goes down) but can jump up.

Here’s my jumping and fall check code:
Jumping

/** Makes player jump */
	private void jump(long elapsedTime) {
		/** Check if player is jumping */
		if(jumping) {
			idle = false;
			/** Increase gravity */
			jumpDistance += gravity;
			//jumping up
			if(jumpDistance < 0) {
				/** Check if hits roof */
				if(validLocation(px, py - moveSpeed)) {
					moveY(-moveSpeed);
				} else {
					jumpDistance = 0;
				}
			// Falling down
			} else if(jumpDistance > 0) {
				moveY(moveSpeed);
			}
			/** Set Jumping Animation */
			if(States.JUMPING > anim.getCurrentState()) {
				anim.setCurrentState(States.JUMPING);
			}
			
			/** Update animation */
			updateAnim(elapsedTime);
		} 
	}

falling check

/** Check if player is falling */
	private void fallCheck() {
		if(!jumping && !onSlope) {
			System.out.println("Fallcheck");
			if(validLocation(px, py + moveSpeed)) {
				jumpDistance = 0;
				jumping = true;
			} 
		}
	}
#7

Hm, well shouldn’t the jumping be linked to a button press, so he can’t jump if no button is being pressed at all?

Also your code seems to be weirdly coupled, which will give you lots of problems. Collision, jumping, etc. should all be separate, not mashed together like that. Something like the pseudo code below:


//Whether or not the jump button on the keyboard is being pressed.
boolean jumpButtonPressed;
//How much longer it is until the player is allowed to jump again.
int jumpDelay;

public void update()
{
    //Some function or whatever that loops through all pressed down keys.
    //Also you might just be using keyPressed(KeyEvent).
    doKeyboardInputForAllKeys();

    if (player.hasBlockUnderneath())
    {
        jumpDelay--;
    }
    else
    {
        //JUMP_WAIT_TIME is some constant that determines for how many timesteps you want the player to "rest" after a landing.
        //Also can be based on an animation rather than a timer.
        jumpDelay = JUMP_WAIT_TIME;
    }

    if (jumpDelay <= 0 && jumpButtonPressed)
    {
        //Normally you would probably put this in a player.jump() function.
        player.velocity.y += player.jumpSpeed;
    }
}

public void doKeyboardInput(KeyPress k)
{
    if (k.key() == JUMP_KEY)
    {
        jumpButtonPressed = true;
    }
}

Does that maybe enlighten you at all?

#8

Thanks for the reply Demonpants! Thanks for the pseudo code too! Actually I do link jumping to a button, below I’ll post my code for the missing part of my code. Also the fallCheck method from previous post is to check whether a player is standing on a walkable tile or not, if not then it moves player down, the actual jumping still requires a player to press the space bar.

Handle key for jumping


/** Handle key press */
	public void keyPressed(KeyEvent e) {
	//Handle other inputs here, left/right/attack etc
		/** Jumping */
		if (e.getKeyCode() == KeyEvent.VK_SPACE && !jumping && !attacking && !pressSpace) {
			space = true;
			pressSpace = true;
		}
	}
	
	/** Handle key release */
	public void keyReleased(KeyEvent e) {	
         //Handle other input here, left/right/attack etc

		/** Jumping */
		if(e.getKeyCode() == KeyEvent.VK_SPACE) {
			space = false;
			pressSpace = false;
		}
	}

And in the actual update method


public void update(long elapsedTime) {
		float dx = 0, dy = 0;
		
		moveSpeed = 0.1f;
		moveSpeed *= elapsedTime * 0.05f;

                /** Player jumping*/
		if(space && !jumping) {
			if(anim.getCurrentState() == States.ATTACKING ||              
                             anim.getCurrentState() == States.HIT) {
			} else {
				idle = false;
				jumping = true;
				jumpDistance = maxJumpHeight;
			}
		}

               /** Make player jump */
		jump(elapsedTime);
}

jump method is called here

/** Makes player jump */
	private void jump(long elapsedTime) {
		/** Check if player is jumping */
		if(jumping) {
			idle = false;
			/** Increase gravity */
			jumpDistance += gravity;
			//jumping up
			if(jumpDistance < 0) {
				/** Check if hits roof */
				if(validLocation(px, py - moveSpeed)) {
					moveY(-moveSpeed);
				} else {
					jumpDistance = 0;
				}
			// Falling down
			} else if(jumpDistance > 0) {
				moveY(moveSpeed);
			}
			/** Set Jumping Animation */
			if(States.JUMPING > anim.getCurrentState()) {
				anim.setCurrentState(States.JUMPING);
			}
			
			/** Update animation */
			updateAnim(elapsedTime);
		} 
	}
#9

This will probably exceed the word limit of a post so I post the collision part here.

Code to move player, inside it “validLocation” checks the collision( this is from Kevin Glass’s tutorial at coke and code

/** Move x and check collision  2010-1-10 */
	public boolean moveX(float dx) {
		/**  work out what the new position of this entity will be */
		float nx = px + dx;
		
		/** Check if next location is a valid one */
		if (validLocation(nx, py)) {
			// if it doesn't then change our position to the new position
			px = nx;
			return true;
		}
		
		/** If blocked don't move */
		return false;
	}
	
	/** Move y and check collision  2010-1-10 */
	public boolean moveY(float dy) {
		/** work out what the new position of this entity will be */
		float ny = py + dy;
		
		/** Check if next location is a valid one */
		if (validLocation(px, ny)) {
			// if it doesn't then change our position to the new position
			py = ny;
			return true;
		}
		
		/** If blocked don't move */
		return false;
	}

Collision Check code:

/** Tile Collision Check */
	private boolean validLocation(float nx, float ny) {
		if(!onSlope) {
			/** Up Left */
			if (map.blocked(nx, ny)) {
				return false;
			}
			/** Up Right */
			if (map.blocked(nx + sizeW, ny)) {
				return false;
			}
			/** Down Left */
			if (map.blocked(nx, ny + sizeH)) {
				/** If player is jumping, change state to IDLE */
				if(jumping) {
					jumping = false;
					jumpDistance = 0;
					idle = true;
				}
				return false;
			}
			/** Down Right */
			if (map.blocked(nx + sizeW, ny + sizeH)) {
				/** If player is jumping, change state to IDLE */
				if(jumping) {
					jumping = false;
					jumpDistance = 0;
					idle = true;
				}
				return false;
			}
		}
		
		/** If none blocked, return true*/
		return true;
	}
#10

I think I’ve found the problem of my jumping bug, its actually the problem of my slope checking method. I’ll explain with a picture so its easier to understand.

  • The blue square is the player, and the center buttom white square is my check point used to check for slope(highlighted by green circle)

-The part highlighted by red circle is where my problem is.

The Slope method works fine in picture 1 and 2, I can move up and down, jump on the slope and its all working fine.

I think in picture 3 its suppose start shifting player to the correct Y displacement, but for some reason the onSlope boolean is false(only shift player if its true) and player shifting never takes place until step 4. I have tried adding an if statement to check if the re is a slope below the player when he’s moving from a high tile onto slope but that didn’t work out either. I’ve spent days on this problem so any help would be greatly appreciated. Thanks in advance!

if statement to check if a player is moving from a high tile onto slope


if(map.onSlope((int)checkX, (int)y + sizeH)) {
			onSlope = true;
			moveY(moveSpeed);
		}


http://img151.imageshack.us/img151/1420/path3712.png

#11

Run your game in an IDE. Create a situation in your game that causes the problem (ie when the box doesn’t follow the slope like it should). Set a breakpoint. Step through your code, checking the value of variables as it executes. You should find your check for “onSlope” is returning false. Stepping through will let you see why it returns false, and that is your problem. Post the check that is wrong, then we can help further. :slight_smile:

#12

Ok, thanks I was on a trip and I just got back I’ll do that once I’m free, thanks for the reply!

#13

my 2cents help… as I did not really not understand the whole stuff :slight_smile:

according to your draw and if I understand right… may be this one is wrong :

/** moving from a plateform down to the slope */
		} else if(map.onSlope(x + sizeW / 2, y  + 1) && !jumping) {
			onSlope = true;

no ?

“y+1” may be replaced by “y-1 or - 2 - 3” ? or something like that

#14

“y + 1” is intended to check for slope below player, wouldn’t y-1, -2 be checking the slope above player? I think my problem happens when entering/exiting the slope, so I’m doing the check suggested by Nate now and I’ll post back with the results. Thanks again for the help =)

Here are the test results:

Note:

  • checkX/checkY is the X/Y position to check slope collision(where the white square is)

  • onSlope is a boolean to tell if player is currently on a slope

  • playerX/playerY is the current position of player(top left of the blue square)

  1. Entering slope from a higher tile, from tile 6 -> 7 in X direction, tile 2 -> 3 in Y direction

    http://img714.imageshack.us/img714/1420/path3712.png

checkX checkY onSlope playerX playerY
6.0249996 2.96 false 5.7 2.31
6.0249996 2.96 false 5.7 2.31
6.0249996 2.96 false 5.7 2.31
6.0249996 2.96 false 5.7 2.31
6.0249996 2.96 false 5.7 2.31

  1. When player X is somewhere near 6.0, the jump bug occurs (5.99999999…/6.0111111111… will cause this problem too)

checkX checkY onSlope playerX playerY
6.325 2.96 false 6.0 2.31
6.325 2.96 false 6.0 2.31
6.325 2.96 false 6.0 2.31
6.325 2.96 false 6.0 2.31
6.325 2.96 false 6.0 2.31
6.325 2.96 false 6.0 2.31
6.325 2.96 false 6.0 2.31
6.325 3.8730001 true 6.0 2.3249998
6.325 2.975 false 6.0 2.3249998
6.325 2.975 false 6.0 2.3249998
6.325 2.975 false 6.0 2.3249998
6.325 2.975 false 6.0 2.3249998
6.325 2.975 false 6.0 2.3249998
6.325 3.8525 true 6.0 2.3249998

3)From playerX = 6.1 onwards everything is fine, the first couple onSlope = false is when player is falling onto the slope.


http://img22.imageshack.us/img22/1420/path3712.png

checkX checkY onSlope playerX playerY
6.4249997 2.96 false 6.1 2.31
6.4249997 2.96 false 6.1 2.31
6.4249997 2.96 false 6.1 2.31
6.4249997 2.96 false 6.1 2.31
6.4249997 2.96 false 6.1 2.31
6.4249997 2.96 false 6.1 2.31
6.4249997 2.96 false 6.1 2.31
6.4249997 3.8725 true 6.1 2.4249997
6.4249997 3.0749998 true 6.1 2.4249997
.
.
.
.
.
6.4249997 3.0749998 true 6.1 2.4249997

#15

I’ve found my bug and fixed it, now my slope is looking good, thanks for everyone that has helped me! ;D

#16

Well - what was it?

Also, congrats on finding it! Way to persevere.

#17

The problem was at the if statement that checks if player is moving from a higher tile onto a slope. I made some slight modifications and added (int) cast to the check and it works ;D There are still some minor bugs like mini screen shake when moving on slope and the moving from slopt -> higher tile not playing the correct running animation(it plays jumping), but other than that the slope is looking good, now I need to work on shifting player from Map 1 to a different map and I have a half working game ;D Thanks again for the help!

This here fix the jump bug:

	
/** Enter slope from higher tile */
		if(map.onSlope(tileX, tileY + 1) && !jumping) {
			py = tileY + 0.4f;
		}

Here’s the working code


/** Check if there's a slope and shift Y according to it */
	int prevSlopeType = -1;
	private void checkSlope(float x, float y) {
		/** X used for slope check */
		float checkX = x + sizeW / 2;
		/** Y used for slope check */
		float checkY = y + sizeH;
		
		int tileX = (int)checkX;
		int tileY = (int)checkY;
		
		int slopeType = map.slopeStyle(tileX, tileY);
		
		/** Enter slope from higher tile */
		if(map.onSlope(tileX, tileY + 1) && !jumping) {
			py = tileY + 0.4f;
		}
		/** On slope, shift Y, ignore check if jumpDistance < 0, ie player jumping up */
		if(map.onSlope(tileX, tileY) && !(jumping && jumpDistance < 0)) {
			onSlope = true;
			jumping = false;
			idle = false;
			float xpos = checkX - tileX;
			if(slopeType == Map.SLOPE_L) {
				prevSlopeType = Map.SLOPE_L;
				py = tileY + 1 - sizeH - xpos;
			} 
			if(slopeType == Map.SLOPE_R) {
				prevSlopeType = Map.SLOPE_R;
				py = tileY + 1 - sizeH - (1 - xpos);
			}
		} else {
			if((prevSlopeType == Map.SLOPE_L && faceDir == States.RIGHT) || (prevSlopeType == Map.SLOPE_R && faceDir == States.LEFT)) {
				py = tileY - sizeH - 0.1f;
			}
			onSlope = false;
			prevSlopeType = Map.NOT_ON_SLOPE;
		}
	}
#18

Aaaah, yes I’ve had rounding errors like that too. I typically would typecast to an int as you did or instead of looking for equality subtracting them and looking for a range less than 0.00001 or something.

#19

Yea, type cast is a magnificent tool ;D