/** 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;
      }
   }

//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;
    }
}

/** 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;
   }

/** 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;
   }

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

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

/** 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;
      }
   }