Ejemplo n.º 1
0
 public boolean contains(SpaceBody body) {
   return ((Math.abs(Global.to_pixels(body.get_body().getPosition().x)) <= SPACE_BOUNDARY_X)
       && (Math.abs(Global.to_pixels(body.get_body().getPosition().y)) <= SPACE_BOUNDARY_Y));
 }
Ejemplo n.º 2
0
  @Override
  public void accelerate(float ax, float ay) {

    float maxX = maxSpeedX;
    float maxY = maxSpeedY;
    float maxFall = maxFallVelocity;

    if (m_slip) {
      ax = ax / 2f;
      maxX = (maxX * 2f);
    }

    m_dx += ax;
    m_dy += ay;

    if (m_bounce) {
      maxX = 40;
      maxY = 40;
      maxFall = 40;
    }

    if ((m_inSwamp) && (m_dying == false)) {
      maxX = maxX / 6;
      maxFall = 4;
    }

    if (Math.abs(m_dx) > maxX) {
      if (!m_inSwamp) {
        if (m_slip) {
          m_dx = maxX * (m_dx / Math.abs(m_dx));
        } else if (!m_onGround) {
          if (m_slipTicks > 30) {
            if (m_dx > 0) m_dx = m_dx - 0.5f;

            if (m_dx < 0) m_dx = m_dx + 0.5f;
          } else {
            if (m_dx > 0) {
              m_dx = (maxX * 2f);
            } else {
              m_dx = -(maxX * 2f);
            }
          }
        } else {
          if (m_dx > 0) m_dx = m_dx - 0.5f;

          if (m_dx < 0) m_dx = m_dx + 0.5f;
        }
      } else {
        m_dx = maxX * (m_dx / Math.abs(m_dx));
      }
    }

    if (m_climbing) {
      if (Math.abs(m_dy) > maxY) {
        m_dy = maxY * (m_dy / Math.abs(m_dy));
      }
    } else {
      if (m_dy < -maxFall) {
        m_dy = -maxFall;
      }

      if ((m_inSwamp) && (m_dying == false)) {
        if (m_dy > 3f) m_dy = 3f;
      }

      if ((m_inFloat) && (m_dying == false)) {
        if (m_dy < m_floatMaxYDown) {
          // m_dy += 0.25f;
          m_dy = m_floatMaxYDown;
        }
      }
    }
  }
Ejemplo n.º 3
0
  public void move() {

    m_slipTicks++;

    boolean alignX = false;

    if (m_ignoreHits > 0) {
      m_ignoreHits--;
    }

    if (m_bounceTicks > 0) {
      m_bounceTicks--;
    } else {
      m_bounce = false;
    }

    if (m_attacking) {
      if (m_attackTicks > 0) {
        m_attackTicks--;
      } else {
        m_attacking = false;
        m_attackPauseTicks = m_activeWeapon.getPauseTicks();
      }
    } else if (m_attackPauseTicks > 0) {
      m_attackPauseTicks--;
    }

    if (m_focus) {
      m_gameLayer.playerSprite.setPosition(this.getX() + this.getWidth() / 2 - 20, this.getY());
      if (((m_inputManager.isJumpPressed()) || (m_inputManager.isDownPressed())) && m_canExit) {
        m_gameLayer.playerSprite.exitBuggy(
            this.getX() + this.getWidth() / 2 - 20, this.getY(), m_currDir);
        m_focus = false;
      }
    }

    // Move Y Now

    if (m_inFloat) {
      this.accelerate(0, -(m_gravity / 4f));
    } else {
      this.accelerate(0, -m_gravity);
    }

    // check for collisions above, below, right, and left.
    float xx = this.getX() + m_dx + this.getWidth() / 2;
    float bottomY = this.getY() + m_dy;
    float topY = this.getY() + this.getHeight();

    int tileX = (int) Math.floor(xx / tw);
    int tileY = (int) Math.floor(bottomY / th);

    // this.getCollisions(tileX,tileY, m_platformTiles);
    // this.getPlatformCollisions(xx,this.getY() + m_dy);

    int lc = getCellAt(tileX, tileY);

    if (m_collisionPlatform == null) {
      m_onPlatform = false;
      m_activePlatform = null;
    }

    // If moving down
    if (m_dy < 0) {
      if (lc >= 0) {
        this.setPosition(this.getX(), (tileY + 1) * th);
        m_onGround = true;
        m_doubleJumping = false;
        this.playLandSound();
        m_dy = 0;
      } else if (m_collisionPlatform != null) {
        // hit a platform
        this.setPosition(
            this.getX(), (m_collisionPlatform.getY() + m_collisionPlatform.getHeight() - 1f));
        m_onGround = true;
        m_onPlatform = true;
        m_activePlatform = m_collisionPlatform;
        m_doubleJumping = false;
        m_onLadder = false;
        m_climbing = false;
        this.playLandSound();
        m_dy = 0;
      } else {
        m_onGround = false; // THIS IS NEW
      }
    } else {
      // moving up
      if (m_dy > 0) {
        tileY = (int) Math.floor(topY / th);
        lc = getCellAt(tileX, tileY);
        if (lc >= 0) {
          m_dy = 0;
          this.setPosition(this.getX(), (tileY * th) - this.getHeight());
          m_onGround = false;
          m_climbing = false;
          m_doubleJumping = false;
        } else {
          m_onGround = false;
        }
      }
    }

    if (m_onGround) {
      bottomY = this.getY() + m_dy;
      int nny = (int) Math.floor(bottomY / th) - 1;
      int cellUnder = getCellAt(tileX, nny);
      if ((cellUnder > 8) && (cellUnder < 11)) {
        m_slip = true;
        m_slipTicks = 0;
      } else {
        m_slip = false;
      }

      if (cellUnder == 4) {
        this.dieNow();
        return;
      }
    }
    // end vertical move

    if ((!m_bounce) && m_focus) {
      float cx = 0.7f;
      if (m_inFloat) cx = cx / 2f;

      if (m_inputManager.isLeftPressed()) {
        this.accelerate(-cx, 0);
      } else if (m_inputManager.isRightPressed()) {
        this.accelerate(cx, 0);
      } else {
        // no left, right...so add horizontal drag
        if (m_onGround == false) {
          if (m_slipTicks > 60) {
            m_dx = this.applyDrag(m_dx, m_horizontalDragFactor);
          } else {
            m_dx = this.applyDrag(m_dx, m_horizontalDragFactor / 4f);
          }
        } else {
          m_dx = this.applyDrag(m_dx, m_horizontalDragFactor);
        }
      }
    }

    if (m_focus == false) {
      m_dx = this.applyDrag(m_dx, m_horizontalDragFactor);
    }

    if ((m_attacking) && (m_onGround) && (m_activeWeapon.stopMovingWhenAttacking()) && (!m_slip)) {
      m_dx = 0;
    }

    // check collisions X
    // check for collisions above, below, right, and left.
    float leftX = this.getX() + m_dx;
    float middleX = this.getX() + m_dx + this.getWidth() / 2;
    float rightX = this.getX() + m_dx + this.getWidth();

    float yy = this.getY();

    tileX = (int) Math.floor(leftX / tw);
    tileY = (int) Math.floor(yy / th);

    // collisions on left side?
    if (m_dx < 0) // moving left
    {
      lc = getCellAt(tileX, tileY);
      int tlc = getCellAt(tileX, tileY + 1);
      int ttlc = getCellAt(tileX, tileY + 2);
      if ((lc >= 0) || (tlc > 0) || (ttlc > 0)) {
        float correctX = (tileX + 1) * tw;
        float nx = correctX - this.getX();
        if (nx > 0) {
          m_dx = 0;
          this.setPosition(this.getX() + 1, this.getY());
        } else {
          m_dx = nx;
        }
      }

      if ((lc == 5) || (tlc == 5) || (ttlc == 5)) {
        this.dieNow();
        return;
      }

    } else if (m_dx > 0) // moving right
    {
      tileX = (int) Math.floor(rightX / tw);
      lc = getCellAt(tileX, tileY);
      int tlc = getCellAt(tileX, tileY + 1);
      int ttlc = getCellAt(tileX, tileY + 2);
      if ((lc >= 0) || (tlc > 0) || (ttlc > 0)) {
        float correctX = (tileX * tw) - this.getWidth();
        float nx = correctX - this.getX();
        if (nx < 0) {
          m_dx = 0;
          this.setPosition(this.getX() - 1, this.getY());
        } else {
          m_dx = nx;
        }
      }

      if ((lc == 6) || (tlc == 6) || (ttlc == 6)) {
        this.dieNow();
        return;
      }

    } else if (m_dx == 0) {
      lc = getCellAt(tileX, tileY);
      tileX = (int) Math.floor(rightX / tw);
      int rc = getCellAt(tileX, tileY);
      if (lc > 0) {
        this.setPosition(this.getX() + 1, this.getY());
      } else if (rc > 0) {
        this.setPosition(this.getX() - 1, this.getY());
      }
    }

    if (m_onGround) {
      if (!m_attacking) {
        if (m_dx != 0) {
          if (!m_walkAnimation.isRunning()) {
            this.stopAllAnimations();
            this.stopSound("buggyDrive");
            this.runAnimation(m_walkAnimation);
            this.loopSound("buggyDrive", 0.3f);
          }
        } else {
          if (m_idleAnimation.isRunning()) {

          } else if (!m_standAnimation.isRunning()) {
            this.stopAllAnimations();
            this.runAnimation(m_standAnimation);
            this.stopSound("buggyDrive");
          } else if (m_standAnimation.isRunning()) {
            m_idleTicks++;
            if (m_idleTicks > 180) {
              this.stopAllAnimations();
              this.runAnimation(m_idleAnimation);
              m_idleTicks = 0;
            }
          }
        }
      }
    } else if ((m_inFloat) && (!m_attacking)) {
      if (!m_floatAnimation.isRunning()) {
        this.stopAllAnimations();
        this.runAnimation(m_floatAnimation);
        this.runAnimation(m_floatAnimation2);
        this.stopSound("buggyDrive");
      }
    }

    if (m_dx > 0) {
      this.setScale(1, 1);
      m_currDir = 1;
    } else if (m_dx < 0) {
      this.setScale(-1, 1);
      m_currDir = -1;
    }

    if (m_lightDir != m_currDir) {
      m_lightDir = m_currDir;
      if (m_currDir > 0) {
        pLight.setDirection(0);
        m_lightX = this.getWidth() - 20;
      } else {
        m_lightX = 20;
        pLight.setDirection(180);
      }
    }

    pLight.setPosition(this.getX() + m_lightX, this.getY() + 45);

    m_inSwamp = false;
    m_inFloat = false;
  }
Ejemplo n.º 4
0
  @Override
  public void update(float deltaTime) {

    if (m_pause) return;

    if ((m_energy != 1) && (m_heartbeatSoundId > 0)) {
      this.stopSound("heartbeat");
      m_heartbeatSoundId = -1;
    }

    if (m_levelEnding) {
      if (m_heartbeatSoundId > 0) {
        this.stopSound("heartbeat");
        m_heartbeatSoundId = -1;
      }

      if (m_levelEndingFading == false) {
        this.translate(m_dx, m_dy);
        float deltaX = Math.abs(m_machineX - this.getX());
        float deltaY = Math.abs(m_machineY - this.getY());
        if ((deltaX < 15) && (deltaY < 15)) {
          m_levelEndingFading = true;
          this.runAnimation(m_levelEndingAnimation);
        }
      } else {
        if (m_levelEndingAnimation.isRunning() == false) {
          this.setVisible(false);
          m_alive = false;
        }
      }
    } else if (m_spawning) {
      if (!m_spawnAnimation.isRunning()) {
        m_spawning = false;
      }
    } else if (m_dying == false) {
      if (m_energy == 1) {
        if (m_heartbeatSoundId < 0) {
          m_heartbeatSoundId = this.loopSound("heartbeat", 0.25f);
        }
      }

      float ex = 0;
      if (m_activePlatform != null) {
        ex = m_activePlatform.getDX();
      }

      if (m_pauseMoveTicks > 0) m_pauseMoveTicks--;

      if (m_inTeleport) {
        if (m_teleportState == 0) {
          if (m_teleportOut.isRunning() == false) {
            m_teleportState = 1;
            this.runAnimation(m_teleportAnimation);
            this.playSound("teleport", 0.75f);
          }
        } else if (m_teleportState == 1) {
          if (m_teleportAnimation.isRunning() == false) {
            m_teleportState = 2;
            this.runAnimation(m_teleportIn);
            this.playSound("teleportOut", 0.75f);
          }
        } else if (m_teleportState == 2) {
          if (m_teleportIn.isRunning() == false) {
            m_teleportState = 0;
            m_inTeleport = false;
            m_pauseMoveTicks = 0;
          }
        }
      } else if (m_pauseMoveTicks < 1) {
        this.move();
        this.translate(m_dx + ex, m_dy);
        if ((m_dx != 0) || (m_dy != 0)) {
          lastMoveX = m_dx;
          lastMoveY = m_dy;
        }
      }
    } else if (m_dying == true) {
      if (m_deadState == 1) {

        if (m_deathAnimation.isRunning() == false) {
          pLight.setActive(false);
          m_deadState = 2;
          if (m_explodeDeath) {
            m_climbing = false;
            m_explodeDeath = false;
            m_deadState = 3;
            m_deadTicks = 0;
            m_dx = 0;
            m_dy = 0;
          } else {
            m_climbing = false;
            m_dy = 0;
            this.accelerate(0, 26f);
            maxFallVelocity = 128.0f;
            m_deadTicks = 0;
            m_dx = 0;
            this.playSound("falling", 0.9f);
          }
        }
      } else if (m_deadState == 2) {
        m_deadTicks++;
        this.accelerate(0, -(m_gravity * 1.5f));
        this.translate(m_dx, m_dy);
        if (m_deadTicks > 90) {
          m_alive = false;
          m_deadState = 1;
          m_dying = false;
          m_explodeDeath = false;
        }
      } else if (m_deadState == 3) {
        m_deadTicks++;
        if (m_deadTicks > 130) {
          m_alive = false;
          m_deadState = 1;
          m_dying = false;
          m_explodeDeath = false;
        }
      }
    }
  }