/** Checks of the player hits a stone wall or a door. */
boolean checkCollision() {
return dukeSprite.collidesWith(myWalls, true);
}
/**
* respond to keystrokes by deciding where to move and then moving the pieces and the view window
* correspondingly.
*/
public void requestMove(int hdirection, int vdirection) {
// vdirection < 0 indicates that the user has
// pressed the UP button and would like to jump.
// therefore, if we're not currently jumping,
// we begin the jump.
if ((myIsJumping == NO_JUMP) && (vdirection < 0)) {
myIsJumping++;
} else if (myIsJumping == NO_JUMP) {
// if we're not jumping at all, we need to check
// if the duke should be falling:
// we (temporarily) move the duke down and see if that
// causes a collision with the floor:
dukeSprite.move(0, 1);
// if the duke can move down without colliding
// with the floor, then we set the duke to
// be falling. The variable myIsJumping starts
// negative while the duke is jumping up and
// is zero or positive when the duke is coming
// back down. We therefore set myIsJumping to
// zero to indicate that the duke should start
// falling.
if (!checkCollision()) {
myIsJumping = 0;
}
// we move the duke Sprite back to the correct
// position she was at before we (temporarily) moved
// her down to see if she would fall.
dukeSprite.move(0, -1);
}
// if the duke is currently jumping or falling,
// advance the jump (change the vertical distance
// the duke is supposed to move)
if ((myIsJumping <= MAX_FREE_FALL) && (myIsJumping != NO_JUMP)) {
myIsJumping++;
}
// also accellerate the horizontal motion if the duke
// runs runs in the same horizontal direction for more than
// one game tick:
myIsRunning++;
// But don't accellerate past the maximum speed:
if (myIsRunning > MAX_SPEED) {
myIsRunning = MAX_SPEED;
}
int horizontal = MOVE_LENGTH * myIsRunning;
// if the duke is currently jumping or falling,
// we calculate the vertical distance she should move.
// This is a parabola given by y = (x*x) * (a + b/c)
// where x is how far we have advanced in the jump
// or fall (myIsJumping), and a, b, and c are constants
// based on the screen size. (The actual values are
// read from a properties file and were originally
// computed through trial and error.)
int vertical = 0;
if (myIsJumping != NO_JUMP) {
vertical =
myIsJumping * myIsJumping * JUMP_INT
+ (myIsJumping * myIsJumping * JUMP_FRAC_NUM) / JUMP_FRAC_DENOM;
// for the first half of the jump we go up,
// then for the second half go down:
if (myIsJumping < 0) {
vdirection = -1;
} else {
vdirection = 1;
}
}
// set the sprite to the correct frame based
// on the duke's current motion:
updateSprite(hdirection, vdirection);
boolean vcrash = false;
boolean hcrash = false;
// now calculate the motion one pixel at a time
// (vertically then horizontally) to see precisely
// how far the duke can move in each of the
// requested directions:
while ((vertical >= 1 && !vcrash) || (horizontal >= 1 && !hcrash)) {
dukeSprite.move(0, vdirection);
if (checkCollision()) {
dukeSprite.move(0, -vdirection);
vcrash = true;
} else {
vertical -= 1;
vcrash = false;
myViewWindowY += vdirection;
}
dukeSprite.move(MOVE_BUFFER * hdirection, 0);
if (checkCollision()) {
dukeSprite.move(-MOVE_BUFFER * hdirection, 0);
hcrash = true;
} else {
dukeSprite.move(-MOVE_BUFFER * hdirection, 0);
dukeSprite.move(hdirection, 0);
horizontal -= 1;
hcrash = false;
myViewWindowX += hdirection;
}
}
// If the duke is blocked vertically,
// then the jump or fall in progress stops:
if (vcrash) {
myIsJumping = NO_JUMP;
}
// If the duke is blocked horizontally,
// forget any horizontal accelleration:
if (hcrash) {
myIsRunning = 0;
}
if (dukeSprite.collidesWith(jamesSprite, true)) {
myCanvas.setGameOver();
return;
}
}
