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