So I finally got my implementation of lives fixed, and it works. Now however when I collide with a ghost when I am at 1 life, nothing happens. I can fall to my death enough times for a game over. from what i can tell the problem is that hit collision is not longer working, because it does not detect a hit, I do not fall. the question is why?

update if i kill myself fast enough it works, but if i play for like 30 seconds, it stops the hit collision detection on my ghosts. platforms and springs still work.

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 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();
                }
                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;
             hero.hitSpring();
             listener.highJump();
            }
        }


    private void checkGameOver() {
        if (lives<=0) {
            state = WORLD_STATE_GAME_OVER;
        }
    }
}