world.java

来自「基于J2ME的手机游戏软件。可以控制游戏人物在地图上上下左右行走；可以在地图上放」· Java 代码 · 共 1,063 行 · 第 1/2 页

    else if (drawState == DRAW_STATE_OVER)
    {
      stopCyc++;
      if (stopCyc > 80) {
        gameScreen.close(); //释放主线程
        actor = null;
      }
    }
  }

  private void checkPropArray()
  {
    if (propArray != null) {
      for (int i = 0; i < propArray.length; i++)
      {
        if (propArray[i] != null && !propArray[i].isExist())
        {
          propArray[i] = null;
        }
        else if (propArray[i] != null)
        {
          propArray[i].cycle();
        }
      }
    }
  }

  private void renderProp(Graphics gra)
  {
    for (int i = 0; i < propArray.length; i++)
    {
      if (propArray[i] != null)
      {
        propArray[i].render(gra);
      }
    }
  }

  private void checkBombAndBlastArray()
  {
    for (int i = 0; i < MAX_BOMB_NUM; i++)
    {
      if (bombArray[i] != null)
      {
        if (bombArray[i].isBlast())
        {
          bombArray[i] = null;
          bombNum--;
        }
        else
        {
          bombArray[i].cycle();
        }
      }
     if (blastArray[i] != null)
     {
        if (blastArray[i].isLive() == false)
        {
          blastArray[i] = null;
        }
        else
        {
          blastArray[i].cycle();
        }
      }
    }
  }

  private void checkViewPoint()
  {
//    if (actor.getX() > viewX + viewWidth / 2 && viewX + viewWidth < worldWidth) {
//      viewX = actor.getX() - viewWidth / 2;
//    }
//    if (actor.getX() < viewX + viewWidth / 2 && viewX > 0) {
//      viewX = actor.getX() - viewWidth / 2;
//    }
//    if (actor.getY() > viewY + viewHeight / 2 &&
//        viewY + viewHeight < worldHeight) {
//      viewY = actor.getY() - viewHeight / 2;
//    }
//    if (actor.getY() < viewY + viewHeight / 2 && viewY > 0) {
//      viewY = actor.getY() - viewHeight / 2;
//    }
//    if (viewX < 0) {
//      viewX = 0;
//    }
//    if (viewY < 0) {
//      viewY = 0;
//    }
//    if (viewX + viewWidth > worldWidth) {
//      viewX = worldWidth - viewWidth;
//    }
//    if (viewY + viewHeight > worldHeight) {
//      viewY = worldHeight - viewHeight;
//    }
    if(actor.getX() < worldWidth - gameScreen.width / 2 && actor.getX() > gameScreen.width / 2)
    {
      viewX = actor.getX() - gameScreen.width / 2;
    }
    if(actor.getY() < worldHeight - gameScreen.height / 2 && actor.getY() > gameScreen.height / 2)
    {
      viewY = actor.getY() - gameScreen.height / 2;
    }
  }

  private void checkEnemyArray()
  {
    for (int i = 0; i < enemyArray.length; i++)
    {
      if (enemyArray[i] != null)
      {
        if (enemyArray[i].isDisuse())
        {
          enemyArray[i] = null;
          enemyNum--;
        }
        else
        {
          enemyArray[i].cycle();
        }
      }
    }
  }

  private void renderDestroy(Graphics gra)
  {

    if (hasDestroy)
    {
      for (int i = 0; i < 4; i++)
      {
        if (destroyBrickX[i] != -1 && destroyBrickY[i] != -1)
        {
          destroyBrick.draw(gra, destroyBrickX[i] - viewX
                            , destroyBrickY[i] - viewY
                            , Graphics.TOP | Graphics.LEFT);
        }
      }
    }
  }

  private void renderEnemy(Graphics gra)
  {
    for (int i = 0; i < enemyArray.length; i++)
    {
      if (enemyArray[i] != null)
      {
        enemyArray[i].render(gra);
      }
    }
  }

  private void renderGate(Graphics gra)
  {
    imageSet.draw(gra, PROP_GATE, 0, gateX - viewX, gateY - viewY
                  , Graphics.TOP | Graphics.LEFT);
  }

  private void renderMap(Graphics gra)
  {
    for (int i = 0; i < map.length; i++)
    {
      for (int j = 0; j < map[i].length; j++)
      {
        int x = j * tileWidth;
        int y = i * tileHeight;
        if (x < viewX + viewWidth + 30 && x > viewX - 30
            && y < viewY + viewHeight + 30 && y > viewY - 30)
        {
          if (map[i][j] == TILE1)
          {
            imageSet.draw(gra, TILE_1, 0
                          , x - viewX, y - viewY
                          , Graphics.TOP | Graphics.LEFT);
          }
          if (map[i][j] == TILE2)
          {
            imageSet.draw(gra, TILE_2, 0
                          , x - viewX, y - viewY
                          , Graphics.TOP | Graphics.LEFT);
          }
        }
      }
    }
  }

  private void renderMessage(Graphics gra)
  {
    //	gra.setColor(0x000000);
    //	gra.drawString("SCORE:"+score,10,10,Graphics.TOP|Graphics.LEFT);
    //	gra.drawString("LIFE:"+playerLife,80,10,Graphics.TOP|Graphics.LEFT);
    int n5 = (score % 100000) / 10000;
    int n4 = (score % 10000) / 1000;
    int n3 = (score % 1000) / 100;
    int n2 = (score % 100) / 10;
    int n1 = score % 10;
    imageSet.draw(gra, MONEY, 0, 10, 5, Graphics.TOP | Graphics.LEFT);
    imageSet.draw(gra, NUMBER, n5, 25, 5, Graphics.TOP | Graphics.LEFT);
    imageSet.draw(gra, NUMBER, n4, 35, 5, Graphics.TOP | Graphics.LEFT);
    imageSet.draw(gra, NUMBER, n3, 45, 5, Graphics.TOP | Graphics.LEFT);
    imageSet.draw(gra, NUMBER, n2, 55, 5, Graphics.TOP | Graphics.LEFT);
    imageSet.draw(gra, NUMBER, n1, 65, 5, Graphics.TOP | Graphics.LEFT);

    n3 = ( (clock / 20) % 1000) / 100;
    n2 = ( (clock / 20) % 100) / 10;
    n1 = ( (clock / 20) % 10);
    imageSet.draw(gra, CLOCK, 0, 85, 5, Graphics.TOP | Graphics.LEFT);
    if ( (clock / 20) > 30) {
      imageSet.draw(gra, NUMBER, n3, 100, 5, Graphics.TOP | Graphics.LEFT);
      imageSet.draw(gra, NUMBER, n2, 110, 5, Graphics.TOP | Graphics.LEFT);
      imageSet.draw(gra, NUMBER, n1, 120, 5, Graphics.TOP | Graphics.LEFT);
    }
    else {
      imageSet.draw(gra, NUMBER_RED, n3, 100, 5, Graphics.TOP | Graphics.LEFT);
      imageSet.draw(gra, NUMBER_RED, n2, 110, 5, Graphics.TOP | Graphics.LEFT);
      imageSet.draw(gra, NUMBER_RED, n1, 120, 5, Graphics.TOP | Graphics.LEFT);
    }

    n1 = (playerLife % 10);
    imageSet.draw(gra, HEART, 0, 150, 5, Graphics.TOP | Graphics.LEFT);
    imageSet.draw(gra, NUMBER, n1, 165, 5, Graphics.TOP | Graphics.LEFT);
  }

  public void render(Graphics gra) {
    if (drawState == DRAW_STATE_GAME) {
      gra.setColor(0xa8771c);
      gra.fillRect(0, 0, viewWidth, viewHeight);

      renderGate(gra);
      renderProp(gra);
      renderMap(gra);
      renderBomb(gra);
      renderDestroy(gra);
      renderBlast(gra);
      renderEnemy(gra);
      actor.render(gra);
      renderMessage(gra);
    }
    else if (drawState == DRAW_STATE_MESSAGE) {
      renderStageChange(gra);
    }
    else if (drawState == DRAW_STATE_OVER) {
      renderGameOver(gra);
    }
  }

  public void keyPressed(int key) {
    actor.keyPressed(key);
  }

  public void keyReleased(int key) {
    actor.keyReleased(key);
  }

  public void pause() {
    isPause = true;
    actor.pause();
  }

  public void resume() {
    isPause = false;
    actor.resume();
  }

  public void addBomb(int x, int y, int power) {
    if (x == gateX && y == gateY) {
      if (enemyNum == 0) {
        stageOver();
        return;
      }
    }
    else {
      for (int i = 0; i < MAX_BOMB_NUM; i++) {
        if (bombArray[i] == null) {
          bombArray[i] = new Bomb(this, x, y, power);
          break;
        }
      }
      bombNum++;
    }
  }

  public void addBlast(int x, int y, int power) {
    for (int i = 0; i < MAX_BOMB_NUM; i++) {
      if (blastArray[i] == null) {
        blastArray[i] = new Blast(this, x, y, power);
        break;
      }
    }
  }

  private void renderBomb(Graphics gra) {
    for (int i = 0; i < MAX_BOMB_NUM; i++) {
      if (bombArray[i] != null) {
        bombArray[i].render(gra);
      }
    }
  }

  private void renderBlast(Graphics gra)
  {
    for (int i = 0; i < MAX_BOMB_NUM; i++)
    {
      if (blastArray[i] != null)
      {
        blastArray[i].render(gra);
      }
    }
  }

  private void renderGameOver(Graphics gra)
  {
    gra.setColor(0x000000);
    gra.fillRect(line, 0, 5, 200);
    imageSet.draw(gra, GAMEOVER, 0, viewWidth / 2, viewHeight / 2
                  , Graphics.VCENTER | Graphics.HCENTER);
    line += 5;
  }

  private void renderStageChange(Graphics gra)
  {
    Graphics imageGra = stageChangeImage.getGraphics();
    imageGra.setColor(0x000000);
    imageGra.fillRect(0, 0, viewWidth, viewHeight);
    imageSet.draw(imageGra, STAGE, 0, viewWidth / 2 - 4, viewHeight / 2
                  , Graphics.VCENTER | Graphics.HCENTER);
    imageSet.draw(imageGra, NUMBER, gameMap.getCurrentStage()
                  , viewWidth / 2 + 30, viewHeight / 2 + 1
                  , Graphics.HCENTER | Graphics.VCENTER);
    imageSet.draw(imageGra, LIFE, 0, viewWidth / 2 - 4, viewHeight / 2 + 50
                  , Graphics.VCENTER | Graphics.HCENTER);
    imageSet.draw(imageGra, NUMBER, playerLife, viewWidth / 2 + 25,
                  viewHeight / 2 + 59
                  , Graphics.VCENTER | Graphics.HCENTER);

    gra.drawImage(stageChangeImage, 0, 0, Graphics.TOP | Graphics.LEFT);
  }

  public Actor getActor()
  {
    return actor;
  }

  public Enemy[] getEnemyArray()
  {
    return enemyArray;
  }

  private boolean collidesWithBomb(int tileX, int tileY, boolean isActor)
  {
   int bx = tileY * tileHeight;
    int by = tileX * tileWidth;
    for (int i = 0; i < bombArray.length; i++)
    {
      if (bombArray[i] != null)
      {
        if (bombArray[i].getX() == bx && bombArray[i].getY() == by)
        {
          if (isActor)
          {
            if (bombArray[i].getAcross())
            {
              return false;
            }
            else
              return true;
          }
          else
          {
            return true;
          }
        }
      }
    }
    return false;
  }

  private boolean collidesWithDestroyBrick(int tileX, int tileY)
  {
    if (hasDestroy == false)
    {
      return false;
    }
    int x = tileY * tileWidth;
    int y = tileX * tileHeight;
    for (int i = 0; i < 4; i++)
    {
      if (destroyBrickX[i] >= 0
          && destroyBrickX[i] == x
          && destroyBrickY[i] >= 0
          && destroyBrickY[i] == y)
      {
        return true;
      }
    }
    return false;
  }

  private boolean collidesWithProp(int tileX, int tileY)
  {
    int x = tileY * tileWidth;
    int y = tileX * tileHeight;
    for (int i = 0; i < propArray.length; i++)
    {
      if (propArray[i] != null && x == propArray[i].getX()
          && y == propArray[i].getY())
      {
        propArray[i].action();
        return true;
      }
    }
    return false;
  }

  public boolean canAcross(int tileX, int tileY, boolean isActor)
  {
    if (isActor && propArray != null)
    {
      collidesWithProp(tileX, tileY);
    }

    if (map[tileX][tileY] == TILE1)
      return false;
    if (map[tileX][tileY] == TILE2)
      return false;
    if (collidesWithBomb(tileX, tileY, isActor))
      return false;
    if (collidesWithDestroyBrick(tileX, tileY))
      return false;
    return true;
  }

  public static boolean collidesRect(int[][] a, int[][] b)
  {
    if (a.length > 4 || b.length > 4)
    {
      System.out.println("error7");
      return false;
    }
    int ax1 = a[0][0];
    int ay1 = a[0][1];
    int ax2 = a[1][0];
    int ay2 = a[1][1];
    int ax3 = a[2][0];
    int ay3 = a[2][1];
    int ax4 = a[3][0];
    int ay4 = a[3][1];
    for (int i = 0; i < b.length; i++)
    {
      if (b[i][0] >= ax1 && b[i][0] <= ax2 && b[i][1] >= ay1 && b[i][1] <= ay4)
      {
        return true;
      }
    }
    return false;
  }

  public int getEnemyNum()
  {
    return enemyNum;
  }

  public int getScore()
  {
    return score;
  }

  public void addScore(int buf)
  {
    score = buf + score;
    if (score > MAX_SCORE)
    {
      score = MAX_SCORE;
    }
  }

  public int getDrawState()
  {
    return drawState;
  }

  public void stageOver()
  {
    if (actor.isLive() == false)
    {
      playerLife--;
      if (playerLife == 0)
      {
        gameOver();
      }
      else
      {
        initStage(gameMap.getCurrentStage());
      }
    }
    else if (enemyNum == 0)
    {
      addScore( (clock / 20) * 10);
      int i = gameMap.getCurrentStage();
      if (i + 1 <= gameMap.getTotalStageNum())
      {
        initStage(i + 1);
      }
      else
      {
        gameOver();
      }
    }
  }

  public void gameOver()
  {
    stopCyc = 0;
    drawState = DRAW_STATE_OVER;
  }

  public int getBombNum()
  {
    return bombNum;
  }

  public void addPlayerLife()
  {
    playerLife++;
    if (playerLife > MAX_LIFE)
    {
      playerLife = MAX_LIFE;
    }
  }
}