给我的游戏添加生命

Question

我想完成一些事情。 首先是创造生命，并从3开始。 游戏结束0生活。 如果你被鬼魂击中，就会失去生命。 如果你跌到一定距离以下，就会失去生命。

目前它只是把生活计数和不停止为负。因此它ignoreing我checkGameOver

public class World { 
    public interface WorldListener { 
     public void jump(); 

     public void highJump(); 

     public void hit(); 

     public void coin(); 

     public void dying(); 
    } 

    public static final float WORLD_WIDTH = 10; 
    public static final float WORLD_HEIGHT = 15 * 20; 
    public static final int WORLD_STATE_RUNNING = 0; 
    public static final int WORLD_STATE_NEXT_LEVEL = 1; 
    public static final int WORLD_STATE_GAME_OVER = 2; 
    public static final Vector2 gravity = new Vector2(0, -12); 

    public final Hero hero; 
    public final List<Platform> platforms; 
    public final List<Spring> springs; 
    public final List<Ghost> ghosts; 
    public final List<Coin> coins; 
    public Castle castle; 
    public final WorldListener listener; 
    public final Random rand; 

    public float heightSoFar; 
    public int score; 
    public int state; 
    public int lives=3; 

    public World(WorldListener listener) { 
     this.hero = new Hero(5, 1); 
     this.platforms = new ArrayList<Platform>(); 
     this.springs = new ArrayList<Spring>(); 
     this.ghosts = new ArrayList<Ghost>(); 
     this.coins = new ArrayList<Coin>(); 
     this.listener = listener; 
     rand = new Random(); 
     generateLevel(); 

     this.heightSoFar = 0; 
     this.score = 0; 
     this.state = WORLD_STATE_RUNNING; 
    } 

    private void generateLevel() { 
     float y = Platform.PLATFORM_HEIGHT/2; 
     float maxJumpHeight = Hero.hero_JUMP_VELOCITY * Hero.hero_JUMP_VELOCITY 
       /(2 * -gravity.y); 
     while (y < WORLD_HEIGHT - WORLD_WIDTH/2) { 
      int type = rand.nextFloat() > 0.8f ? Platform.PLATFORM_TYPE_MOVING 
        : Platform.PLATFORM_TYPE_STATIC; 
      float x = rand.nextFloat() 
        * (WORLD_WIDTH - Platform.PLATFORM_WIDTH) 
        + Platform.PLATFORM_WIDTH/2; 

      Platform platform = new Platform(type, x, y); 
      platforms.add(platform); 

      if (rand.nextFloat() > 0.9f 
        && type != Platform.PLATFORM_TYPE_MOVING) { 
       Spring spring = new Spring(platform.position.x, 
         platform.position.y + Platform.PLATFORM_HEIGHT/2 
           + Spring.SPRING_HEIGHT/2); 
       springs.add(spring); 
      } 

      if (rand.nextFloat() > 0.7f) { 
       Ghost ghost = new Ghost(platform.position.x 
         + rand.nextFloat(), platform.position.y 
         + Ghost.GHOST_HEIGHT + rand.nextFloat() * 3); 
       ghosts.add(ghost); 
      } 

      if (rand.nextFloat() > 0.6f) { 
       Coin coin = new Coin(platform.position.x + rand.nextFloat(), 
         platform.position.y + Coin.COIN_HEIGHT 
           + rand.nextFloat() * 3); 
       coins.add(coin); 
      } 

      y += (maxJumpHeight - 0.5f); 
      y -= rand.nextFloat() * (maxJumpHeight/3); 
     } 

     castle = new Castle(WORLD_WIDTH/2, y); 
    } 

public void update(float deltaTime, float accelX) { 
    updatehero(deltaTime, accelX); 
    updatePlatforms(deltaTime); 
    updateGhosts(deltaTime); 
    updateCoins(deltaTime); 
    if (hero.state != Hero.hero_STATE_HIT) 
     checkCollisions(); 
    checkGameOver(); 
    checkFall(); 
} 

private void updatehero(float deltaTime, float accelX) { 
    if (hero.state != Hero.hero_STATE_HIT && hero.position.y <= 0.5f) 
     hero.hitPlatform(); 
    if (hero.state != Hero.hero_STATE_HIT) 
     hero.velocity.x = -accelX/10 * Hero.hero_MOVE_VELOCITY; 
    hero.update(deltaTime); 
    heightSoFar = Math.max(hero.position.y, heightSoFar); 
} 

private void updatePlatforms(float deltaTime) { 
    int len = platforms.size(); 
    for (int i = 0; i < len; i++) { 
     Platform platform = platforms.get(i); 
     platform.update(deltaTime); 
     if (platform.state == Platform.PLATFORM_STATE_PULVERIZING 
       && platform.stateTime > Platform.PLATFORM_PULVERIZE_TIME) { 
      platforms.remove(platform); 
      len = platforms.size(); 
     } 
    } 
} 

private void updateGhosts(float deltaTime) { 
    int len = ghosts.size(); 
    for (int i = 0; i < len; i++) { 
     Ghost ghost = ghosts.get(i); 
     ghost.update(deltaTime); 
     if (ghost.state == Ghost.GHOST_STATE_DYING 
       && ghost.stateTime > Ghost.GHOST_DYING_TIME) { 
      ghosts.remove(ghost); 
      len = ghosts.size(); 
     } 
    } 
} 

private void updateCoins(float deltaTime) { 
    int len = coins.size(); 
    for (int i = 0; i < len; i++) { 
     Coin coin = coins.get(i); 
     coin.update(deltaTime); 
    } 
} 

    private void checkCollisions() { 
     checkPlatformCollisions(); 
     checkGhostCollisions(); 
     checkItemCollisions(); 
     checkCastleCollisions(); 
    } 

    private void checkPlatformCollisions() { 
     if (hero.velocity.y > 0) 
      return; 

     int len = platforms.size(); 
     for (int i = 0; i < len; i++) { 
      Platform platform = platforms.get(i); 
      if (hero.position.y > platform.position.y) { 
       if (OverlapTester 
         .overlapRectangles(hero.bounds, platform.bounds)) { 
        hero.hitPlatform(); 
        listener.jump(); 
        if (rand.nextFloat() > 0.5f) { 
         platform.pulverize(); 
        } 
        break; 
       } 
      } 
     } 
    } 

    private void checkGhostCollisions() { 
     int len = ghosts.size(); 
     for (int i = 0; i < len; i++) { 
      Ghost ghost = ghosts.get(i); 
      if (hero.position.y < ghost.position.y) { 
       if (OverlapTester.overlapRectangles(ghost.bounds, hero.bounds)){ 
        hero.hitGhost(); 
        listener.hit(); 
        lives--; 
       } 
       break; 
      } else { 
      if(hero.position.y > ghost.position.y) { 
       if (OverlapTester.overlapRectangles(hero.bounds, ghost.bounds)){ 
        hero.hitGhostJump(); 
        listener.jump(); 
        ghost.dying(); 
        score += Ghost.GHOST_SCORE; 
       } 
       break; 
       } 
      } 
     } 
    } 


    private void checkItemCollisions() { 
     int len = coins.size(); 
     for (int i = 0; i < len; i++) { 
      Coin coin = coins.get(i); 
      if (OverlapTester.overlapRectangles(hero.bounds, coin.bounds)) { 
       coins.remove(coin); 
       len = coins.size(); 
       listener.coin(); 
       score += Coin.COIN_SCORE; 
      } 

     } 

     if (hero.velocity.y > 0) 
      return; 

     len = springs.size(); 
     for (int i = 0; i < len; i++) { 
      Spring spring = springs.get(i); 
      if (hero.position.y > spring.position.y) { 
       if (OverlapTester.overlapRectangles(hero.bounds, spring.bounds)) { 
        hero.hitSpring(); 
        listener.highJump(); 
       } 
      } 
     } 
    } 

    private void checkCastleCollisions() { 
     if (OverlapTester.overlapRectangles(castle.bounds, hero.bounds)) { 
      state = WORLD_STATE_NEXT_LEVEL; 
     } 
    } 

    private void checkFall() {   
     if (heightSoFar - 7.5f > hero.position.y) { 
     --lives; 
        } 
    } 

     public boolean checkGameOver() { 
      --lives; 
      return isDead(); 
     } 
     public boolean isDead(){ 
      return lives<1; 
     } 

} 

Answer 1

checkGameOver()返回true当生命的数量为零或更少，但你从来没有做任何回应。在update方法，你需要这样的事情：

if (checkGameOver()) { 
    /* show a Game Over screen, or something like that */ 
} 

Answer 2

看来，你忽略的checkGameOver()回报。如果你要经历让它返回一个指示游戏结束的布尔值的麻烦，你应该检查它的返回并且用它做一些事情。

Answer 3

checkGameOver（）返回一个布尔值，但你永远不会做与任何有价值的东西来结束游戏/程序