tanksprite.java

这是我在原来单位的时候写的一个坦克大战的J2ME游戏的代码,可以给其他作J2ME游戏的人作个参考

    if (m_bombCount > 0) {
      m_bombCount--;
      GameLogic.startDestoryEnemies();
      GameLogic.startProperties();
    }
  }

  /**
   * 确定当前子弹的开始位置;
同一组子弹中为上一颗子弹开始位置 ＝ 当前炮口位置
同一组子弹中为上一颗子弹开始位置 ＋ 攻击频率×间隔时间

   * @param bulletSeq int
   * @return int
   */
  public int getGunPositionX(int bulletSeq){//start from 0
    //计算炮口位置.
      int iGunPosX, iGunPosY;
      iGunPosX = iGunPosY = 0;

      switch (m_currentAngel) {
        case Sprite.TRANS_NONE:
          iGunPosX = getRefPixelX();
          /*iGunPosY = getRefPixelY() - (m_frameHeight / 2 )- (BULLET_HEIGHT / 2 )-
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
          iGunPosY = getRefPixelY() - (m_frameHeight / 2 )-
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          break;
        case Sprite.TRANS_ROT180:
          iGunPosX = super.getRefPixelX();
          /*iGunPosY = super.getRefPixelY() + (m_frameHeight / 2) + (BULLET_HEIGHT / 2) +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
		  iGunPosY = super.getRefPixelY() + (m_frameHeight / 2) +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          break;
        case Sprite.TRANS_ROT90:
        /*  iGunPosX = getRefPixelX() + m_frameWidth / 2 + BULLET_WIDTH / 2 +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
		  iGunPosX = getRefPixelX() + m_frameWidth / 2  +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          iGunPosY = getRefPixelY();
          break;
        case Sprite.TRANS_ROT270:
          /*iGunPosX = getRefPixelX() - (m_frameWidth / 2) - (BULLET_WIDTH / 2)-
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
          iGunPosX = getRefPixelX() - (m_frameWidth / 2) -
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          iGunPosY = getRefPixelY();
          break;
        default:
          break;
      }
      return iGunPosX;
  }

  public int getGunPositionY(int bulletSeq){//start from 0
    //计算炮口位置.
      int iGunPosX, iGunPosY;
      iGunPosX = iGunPosY = 0;

      switch (m_currentAngel) {
        case Sprite.TRANS_NONE:
          iGunPosX = getRefPixelX();
          /*iGunPosY = getRefPixelY() - (m_frameHeight / 2 )- (BULLET_HEIGHT / 2 )-
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
          iGunPosY = getRefPixelY() - (m_frameHeight / 2 )-
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          break;
        case Sprite.TRANS_ROT180:
          iGunPosX = super.getRefPixelX();
          /*iGunPosY = super.getRefPixelY() + (m_frameHeight / 2) + (BULLET_HEIGHT / 2) +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
		  iGunPosY = super.getRefPixelY() + (m_frameHeight / 2) +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          break;
        case Sprite.TRANS_ROT90:
        /*  iGunPosX = getRefPixelX() + m_frameWidth / 2 + BULLET_WIDTH / 2 +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
		  iGunPosX = getRefPixelX() + m_frameWidth / 2  +
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          iGunPosY = getRefPixelY();
          break;
        case Sprite.TRANS_ROT270:
          /*iGunPosX = getRefPixelX() - (m_frameWidth / 2) - (BULLET_WIDTH / 2)-
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;*/
          iGunPosX = getRefPixelX() - (m_frameWidth / 2) -
              m_bulletSpeed*(BULLET_TIMER_DELAY/1000)*bulletSeq;
          iGunPosY = getRefPixelY();
          break;
        default:
          break;
      }
      return iGunPosY;
  }

  public void reverse(){
    Random rand=new Random();
    int i=rand.nextInt(1);
    try {

      switch(m_currentDirection){
        case GameLogic.TANK_DIRECTION_UP:
          m_currentDirection=GameLogic.TANK_DIRECTION_LEFT+i;
          break;
        case GameLogic.TANK_DIRECTION_DOWN:
          m_currentDirection=GameLogic.TANK_DIRECTION_LEFT+i;
          break;
        case GameLogic.TANK_DIRECTION_LEFT:
          m_currentDirection= GameLogic.TANK_DIRECTION_UP+i;
          break;
        case GameLogic.TANK_DIRECTION_RIGHT:
          m_currentDirection= GameLogic.TANK_DIRECTION_UP+i;
          break;
      }
    }
    catch (Exception ex) {
      ex.printStackTrace();
    }
    rand=null;
  }

  /**
   * 1.锁住TANK的发射状态,在子弹运行状态下，不允许继续发射子弹。
   2.计算炮口所在位置－－子弹的初始位置。
   */
  public void fire() {
//display scene don't allow to fire
    if(GameLogic.GAME_STATE_PAUSE==m_currentState){
		return;
    }

    if (!m_bulletLocked) {
      try {
        //发射跟踪导弹，只针对用户坦克
        if (m_bulletType == GameLogic.BULLET_TYPE_MISSILE &&
            m_tankOwner == GameLogic.USER_TANK) {
          m_missileCount -= GameLogic.BULLET_MISSILE_PER_FIRE;
          if (m_missileCount <= 0) {
            m_bulletType = GameLogic.BULLET_TYPE_COMMON;
            changeBullet(GameLogic.BULLET_TYPE_COMMON);
            System.out.println("导弹已用完");
            return;
          }
        }

        //一次发射一组子弹。该组子弹中每二个子弹之间的间隔为1s
        m_currentState = GameLogic.GAME_STATE_LOOP;
        m_bulletLocked = true; //该子弹可以运行了

        for (int i = 0; i < m_bulletCount; i++) {
          int iGunPosX = getGunPositionX(i);
          int iGunPosY = getGunPositionY(i);
          m_bullet[i].reset();
          m_bullet[i].setRefPixelPosition(iGunPosX, iGunPosY);
          m_bullet[i].setDirection(m_currentAngel);
        }
        //开始运行第一颗子弹，其他子弹在START状态
        m_bullet[0].start();

        if (null !=m_timer) {
          m_timerTask=new BulletScheduler(this);
          m_timerTask.setTask(BulletScheduler.TASK_TANK_BULLET_FIRE);
          m_timer.schedule(m_timerTask, BULLET_TIMER_DELAY);
        }
      }
      catch (Exception e) {
        e.printStackTrace();
      }

    }
  }

  public void double_points_timeout() {
    //30秒内击毁坦克积分翻倍；（×2)
    if (null != m_timerTaskDoublePoints) {
      m_timerTaskDoublePoints = null;
    }
    m_doublePoints = false;
  }

  public void invicible_timeout() {
    if (null != m_timerTaskInvicible) {
      m_timerTaskInvicible = null;
    }
    m_invicible = false;
  }


  public int getGameState(){
    return m_currentState;
  }

  public void timeout() {
    //don't allow to fire when in pause state,cos the tank is displaying scenes
    if (m_currentState == GameLogic.GAME_STATE_PAUSE) {
      return;
    }

    m_curretBullet++;

    //一组子弹启动完毕
    if (m_curretBullet >= m_bulletCount) {
      m_currentState = GameLogic.GAME_STATE_LOOP; //等待所有子弹完成
    }
    else {
      //启动下颗子弹
        m_timerTask=null;
        m_timerTask = new BulletScheduler(this);
        m_timerTask.setTask(BulletScheduler.TASK_TANK_BULLET_FIRE);
        m_timer.schedule(m_timerTask, BULLET_TIMER_DELAY);

      m_bullet[m_curretBullet].start();
      m_currentState = GameLogic.GAME_STATE_LOOP; //等待所有子弹完成
    }
  }

  public void reduce_life(int damage) {
    //无敌模式下　不少血
    if (true == m_invicible) {
      return;
    }

    m_tankBlood -= damage;
    if (m_tankBlood <= 0) {
      m_tankBlood=0;
      m_tankLife--;
      if (0 >= m_tankLife) {
        m_tankLife = 0;
        pause();
      }
      else {
        pause();
      }
    }
  }

  public boolean isAlive() {
    return (m_tankLife > 0) ? true : false;
  }


  private void setGameState(int state){
    m_currentState = state;
  }


  protected void getCurrentFrame() {
    switch (m_tankType) {
      case GameLogic.TANK_RETIRED:
      case GameLogic.TANK_COMMON:
      case GameLogic.GREEN_TANK_SPECIAL:
      case GameLogic.TANK_BABY:
        if (GameLogic.TANK_DIRECTION_UP == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_IMAGE_UP_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_IMAGE_UP_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_DOWN == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_IMAGE_DOWN_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_IMAGE_DOWN_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_LEFT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_IMAGE_LEFT_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_IMAGE_LEFT_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_RIGHT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_IMAGE_RIGHT_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_IMAGE_RIGHT_RUN;
        }
        break;
      case GameLogic.TANK_RETIRED_PLUS:
      case GameLogic.TANK_COMMON_PLUS:
      case GameLogic.GREEN_TANK_SPECIAL_PLUS:
      case GameLogic.TANK_ENEMY_TYPE2:
        if (GameLogic.TANK_DIRECTION_UP == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUS_IMAGE_UP_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUS_IMAGE_UP_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_DOWN == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUS_IMAGE_DOWN_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUS_IMAGE_DOWN_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_LEFT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUS_IMAGE_LEFT_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUS_IMAGE_LEFT_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_RIGHT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUS_IMAGE_RIGHT_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUS_IMAGE_RIGHT_RUN;
        }
        break;
      case GameLogic.TANK_RETIRED_PLUSPLUS:
      case GameLogic.TANK_COMMON_PLUSPLUS:
      case GameLogic.GREEN_TANK_SPECIAL_PLUSPLUS:
      case GameLogic.TANK_ENEMY_TYPE3:
        if (GameLogic.TANK_DIRECTION_UP == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_UP_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_UP_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_DOWN == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_DOWN_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_DOWN_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_LEFT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_LEFT_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_LEFT_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_RIGHT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_RIGHT_STILL;
          m_currentFrame[1] = GameLogic.RETIRED_TANK_PLUSPLUS_IMAGE_RIGHT_RUN;
        }

        break;
        // case GameLogic.TANK_SPECIAL:
        // break;
      case GameLogic.TANK_ENEMY_TYPE1:
        if (GameLogic.TANK_DIRECTION_UP == m_currentDirection) {
          m_currentFrame[0] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_UP_STILL;
          m_currentFrame[1] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_UP_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_DOWN == m_currentDirection) {
          m_currentFrame[0] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_DOWN_STILL;
          m_currentFrame[1] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_DOWN_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_LEFT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_LEFT_STILL;
          m_currentFrame[1] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_LEFT_RUN;
        }
        else if (GameLogic.TANK_DIRECTION_RIGHT == m_currentDirection) {
          m_currentFrame[0] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_RIGHT_STILL;
          m_currentFrame[1] = GameLogic.TANK_ENEMY_TYPE1_IMAGE_RIGHT_RUN;
        }
        break;
      default:
        break;
    }
    setFrameSequence(m_currentFrame);
  }
  /**
   *
1.根据当前的按键确定TANK的炮口方向。
2.在TANK的炮口方向上移动TANK.
   */
  public void move(int iAngel, int iStep) {
    boolean bLastTurn=false;
    try {
      //1.根据当前的按键确定TANK的炮口方向
      //setTransform(iAngel);
      //3.在TANK的炮口方向上移动TANK.
      //iStep = m_tankSpeed;


      //move in the same direction,continue move,else don't change position
      switch (iAngel) {
        case Sprite.TRANS_ROT180:
          iStep = 0 - iStep;
        case Sprite.TRANS_NONE:
          forward(iStep,iAngel);
          break;
        case Sprite.TRANS_ROT270:
          iStep = 0 - iStep;
        case Sprite.TRANS_ROT90:
          turn(iStep,iAngel);
          break;
      }

      //如果坦克移动方向改变，需要改变运动轨迹,
      //如果坦克移动方向改变，这个时候UNDO的值变为0;
      if (m_currentAngel != iAngel) {
        getCurrentFrame();
      }
      m_currentAngel = iAngel;

      nextFrame();
      
      if(m_tankOwner == GameLogic.USER_TANK){
    	  GameLogic.collidesWith(this,m_tankOwner);
      }
    }
    catch (Exception e) {
      e.printStackTrace();
    }
  }

  public int getPoints(){
  	return m_tankPoints;
  }

  public int getBombCount(){
  	return m_bombCount;
  }

  public int getTankLives(){
  	return m_tankLife;
  }

  public int getTankDirection(){
    return m_currentDirection;
  }

  public int getTankBlood(){
  	return m_tankBlood;
  }

  public int getTankType(){
  	return m_tankType;
  }

  public int getTankOwner(){
    return m_tankOwner;
  }

  public int getTankIndex(){
  	return m_tankIndex;
  }
  
  public void setUnderAttackFlag(boolean flag){
	  m_underAttack=flag;
  }
  
  public void setBackToNormalFlag(boolean flag){
	  m_backToNormal=flag;
  }
  
  public void setCellToBeAvoided(int row, int col) {
		/**
		 * 1.this function is only available when
		 * 
		 */
		if (row == m_rowCollided && col == m_colCollided) {
			return;
		}
		
		if(true==m_underAttack || true==m_backToNormal){
			m_rowCollided = row;
			m_colCollided = col;
			GameLogic.map_element[col][row][GameLogic.MAP_ELEMENT_PROPERTY_GRID_TYPE] = 9;
			System.out.println("setCellToBeAvoided col=" + col + " row=" + row);
		}
	}

  public void resetCellToBeAvoided() {
	  if(true==m_underAttack || true==m_backToNormal){
		  GameLogic.map_element[m_colCollided][m_rowCollided][GameLogic.MAP_ELEMENT_PROPERTY_GRID_TYPE] = 1;
			System.out.println("reset CellToBeAvoided col=" + m_colCollided
					+ " row=" + m_rowCollided);
			m_rowCollided = 0;
			m_colCollided = 0;
	  }
	}
  
  public void setEnemyAttacked(int enemyIndex){
	  m_enemiesAttacked.addElement(new Integer(enemyIndex));
  }

  public void setPoint(int points){
  	m_tankPoints=points;
  }

  public void setTankLives(int lives){
    m_tankLife=lives;
  }

//保存坦克的开始位置 ，这样当坦克重新复活时可以出现在这个位置；
  public void setRefPixelPosition(int x,
                                  int y) {
    mKX = x;//当前坦克移动后的X坐标
    mKY = y;//当前坦克移动后的Y坐标

    if (!m_init) {
      m_startPositionX = x;
      m_startPositionY = y;
      m_init = true;
    }

    super.setRefPixelPosition(x, y);
}
}

class BulletScheduler extends TimerTask{
  private TankSprite m_tank;
  private int m_task;

  public static final int TASK_TANK_INVICIBLE = 1;
  public static final int TASK_TANK_DOUBLE_POINTS = 2;
  public static final int TASK_TANK_BULLET_FIRE = 3;

  BulletScheduler(TankSprite tank){
    m_tank = tank;
  }

  public void setTask(int task){
  	m_task = task;
  }

  public void run(){
    switch (m_task) {
      case TASK_TANK_BULLET_FIRE:
        m_tank.timeout();
        break;
      case TASK_TANK_INVICIBLE:
	  	m_tank.invicible_timeout();
        break;
      case TASK_TANK_DOUBLE_POINTS:
	  	m_tank.double_points_timeout();
        break;
      default:
        break;
    }
  }
}