public void headlightsOn() {
   pLight.setActive(true);
   pLight.setPosition(this.getX() + m_lightX, this.getY() + 45);
 }
  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;
  }