actor.java~7~

来自「基于J2ME的手机游戏软件。可以控制游戏人物在地图上上下左右行走；可以在地图上放」· JAVA~7~ 代码 · 共 496 行

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Canvas;

public class Actor
    implements Runnable {
  public static final int REMAIN_CYC = 40;

  public static final int MAX_POWER = 10;
  public static final int MAX_BOMB_NUM = 10;

  public static final int UP = Canvas.UP;
  public static final int DOWN = Canvas.DOWN;
  public static final int LEFT = Canvas.LEFT;
  public static final int RIGHT = Canvas.RIGHT;
  public static final int FIRE = Canvas.FIRE;

  public static final int DIR_STATIC = 0;
  public static final int DIR_UP = 1;
  public static final int DIR_DOWN = 2;
  public static final int DIR_LEFT = 3;
  public static final int DIR_RIGHT = 4;

  public static final int STATE_INIT = 1;
  public static final int STATE_PLAYING = 2;
  public static final int STATE_END = 3;

  private int posX;
  private int posY;
  private int step;
  private int width;
  private int height;
  private World world;
  private boolean live;
  private boolean disuse;
  private int direction;
  private ImageSet imageSet;
  private Sprite sprite;
  private boolean isPause;
  private int state;
  private int power;
  private int bombNum;
  private int bodyRemainCyc;

  public Actor(World world, int x, int y) {
    this.world = world;
    step = 4;
    width = 24;
    height = 32;
    imageSet = world.getImageSet();
    sprite = new Sprite(imageSet, world.ACTOR_STATIC, 0);
    isPause = false;
    power = 1;
    bombNum = 1;
    init(x, y);
    state = STATE_INIT;
  }

  public void init(int x, int y) {
    posX = x;
    posY = y;
    live = true;
    disuse = false;
    direction = DIR_STATIC;
    sprite.setCurrentState(world.ACTOR_STATIC, true);
    bodyRemainCyc = REMAIN_CYC;
  }

  public void start() {
    if (state == STATE_INIT || state == STATE_END) {
      Thread t = new Thread(this);
      t.start();
      //	System.out.println("k");
    }
    state = STATE_PLAYING;
  }

  private void swerve(int dir) { //平滑转向
    int x = posX;
    int y = posY;
    int tileX_1 = -1;
    int tileY_1 = -1;
    int tileX_2 = -1;
    int tileY_2 = -1;
    //	int[][] bufMap = world.getMap();
    switch (dir) {
      case UP:
        y = y - step;
        tileY_1 = x / world.getTileWidth();
        tileX_1 = y / world.getTileHeight();
        tileY_2 = (x + width) / world.getTileWidth();
        tileX_2 = y / world.getTileHeight();
        if (world.canAcross(tileX_1, tileY_1, true)
            && !world.canAcross(tileX_2, tileY_2, true)
            && (posX + width / 2) < tileY_2 * world.getTileWidth()) {
          left();
        }
        else if (!world.canAcross(tileX_1, tileY_1, true)
                 && world.canAcross(tileX_2, tileY_2, true)
                 && (posX + width / 2) > tileY_1
                 * world.getTileWidth() + world.getTileWidth()) {
          right();
        }
        break;
      case DOWN:
        y = y + step;
        tileY_1 = x / world.getTileWidth();
        tileX_1 = (y + height) / world.getTileWidth();
        tileY_2 = (x + width) / world.getTileWidth();
        tileX_2 = (y + height) / world.getTileHeight();
        if (world.canAcross(tileX_1, tileY_1, true)
            && !world.canAcross(tileX_2, tileY_2, true)
            && (posX + width / 2) < tileY_2 * world.getTileWidth()) {
          left();
        }
        else if (!world.canAcross(tileX_1, tileY_1, true)
                 && world.canAcross(tileX_2, tileY_2, true)
                 && (posX + width / 2) > tileY_1
                 * world.getTileWidth() + world.getTileWidth()) {
          right();
        }
        break;
      case LEFT:
        x = x - step;
        tileY_1 = x / world.getTileWidth();
        tileX_1 = y / world.getTileHeight();
        tileY_2 = x / world.getTileWidth();
        tileX_2 = (y + height) / world.getTileHeight();
        if (world.canAcross(tileX_1, tileY_1, true)
            && !world.canAcross(tileX_2, tileY_2, true)
            && (posY + height / 2) < tileX_2 * world.getTileHeight()) {
          up();
        }
        else if (!world.canAcross(tileX_1, tileY_1, true)
                 && world.canAcross(tileX_2, tileY_2, true)
                 && (posY + height / 2) > tileX_1
                 * world.getTileHeight() + world.getTileHeight()) {
          down();
        }
        break;
      case RIGHT:
        x = x + step;
        tileY_1 = (x + width) / world.getTileWidth();
        tileX_1 = y / world.getTileHeight();
        tileY_2 = (x + width) / world.getTileWidth();
        tileX_2 = (y + height) / world.getTileHeight();
        if (world.canAcross(tileX_1, tileY_1, true)
            && !world.canAcross(tileX_2, tileY_2, true)
            && (posY + height / 2) < tileX_2 * world.getTileHeight()) {
          up();
        }
        else if (!world.canAcross(tileX_1, tileY_1, true)
                 && world.canAcross(tileX_2, tileY_2, true)
                 && (posY + height / 2) > tileX_1
                 * world.getTileHeight() + world.getTileHeight()) {
          down();
        }
        break;
    }
  }

  public void cycle()
  {
    if (live) {
      sprite.cycle();
    }
    else if (!disuse)
    {
      bodyRemainCyc--;
      if (bodyRemainCyc < 0)
      {
        disuse = true;
      }
      //	System.out.println(bodyRemainCyc);
    }
  }

  public void render(Graphics gra)
  {
    //	gra.setColor(0xff00ff);
    //	gra.fillRect(posX - world.getViewX(),posY - world.getViewY(),width,height);
    if (live)
    {
      sprite.draw(gra, posX - world.getViewX()
                  , posY - world.getViewY()
                  , Graphics.TOP | Graphics.LEFT);
      gra.setColor(0xff0000);
      gra.drawRect(posX - world.getViewX(), posY - world.getViewY()
                   , width - 1, height - 1);
    }
    else if (!disuse)
    {
      imageSet.draw(gra, world.ACTOR_DEAD, 0, posX - world.getViewX()
                    , posY - world.getViewY()
                    , Graphics.TOP | Graphics.LEFT);
    }
  }

  public void up()
  {
    if (!collidesDetect(posX, posY - step)) {
      posY = posY - step;
    }
    else
    {
      swerve(UP);
    }

  }

  public void down()
  {
    if (!collidesDetect(posX, posY + step))
    {
      posY = posY + step;
    }
    else
    {
      swerve(DOWN);
    }

  }

  public void right() {
    if (!collidesDetect(posX + step, posY)) {
      posX = posX + step;
    }
    else {
      swerve(RIGHT);
    }

  }

  public void left() {

    if (!collidesDetect(posX - step, posY)) {
      posX = posX - step;
    }
    else {
      swerve(LEFT);
    }

  }

  public void fire() {
    putBomb(world.getMap());
  }

  public int getX() {
    return posX;
  }

  public int getY() {
    return posY;
  }

  public void setX(int x) {
    posX = x;
  }

  public void setY(int y) {
    posY = y;
  }

  public int getStep() {
    return step;
  }

  public void dead() {
    live = false; //释放ACTOR线程
  }

  //Collides detect with map[][]
  private boolean collidesDetect(int x, int y) {
    int x1 = x;
    int y1 = y;
    int x2 = x1 + width - 1;
    int y2 = y1;
    int x3 = x1 + width - 1;
    int y3 = y1 + height - 1;
    int x4 = x1;
    int y4 = y1 + height - 1;
    int tileX = -1;
    int tileY = -1;
    int tileH = world.getTileHeight();
    int tileW = world.getTileWidth();
    //detected up-left
    tileX = y1 / tileH;
    tileY = x1 / tileW;
    if (!world.canAcross(tileX, tileY, true)) {
      //	System.out.println("1");
      return true;
    }

    tileX = y2 / tileH;
    tileY = x2 / tileW;
    if (!world.canAcross(tileX, tileY, true)) {
      //	System.out.println("2");
      return true;
    }

    tileX = y3 / tileH;
    tileY = x3 / tileW;
    if (!world.canAcross(tileX, tileY, true)) {
      //	System.out.println("3");
      return true;
    }

    tileX = y4 / tileH;
    tileY = x4 / tileW;
    if (!world.canAcross(tileX, tileY, true)) {
      //	System.out.println("4");
      return true;
    }
    return false;
  }

  public void keyPressed(int key) {
    if (live && !isPause && world.getDrawState() == world.DRAW_STATE_GAME) {
      switch (key) {
        case UP:
          direction = DIR_UP;
          sprite.setCurrentState(world.ACTOR_RUN_UP, true);
          break;
        case DOWN:
          direction = DIR_DOWN;
          sprite.setCurrentState(world.ACTOR_RUN_DOWN, true);
          break;
        case RIGHT:
          direction = DIR_RIGHT;
          sprite.setCurrentState(world.ACTOR_RUN_RIGHT, true);
          break;
        case LEFT:
          direction = DIR_LEFT;
          sprite.setCurrentState(world.ACTOR_RUN_LEFT, true);
          break;
        case FIRE:
          fire();
          break;
      }
    }

  }

  public void keyReleased(int key) {
    if (live && !isPause) {
      switch (key) {
        case UP:
          if (direction == DIR_UP) {
            direction = DIR_STATIC;
            sprite.setCurrentState(world.ACTOR_STATIC, true);
          }

          break;
        case DOWN:
          if (direction == DIR_DOWN) {
            direction = DIR_STATIC;
            sprite.setCurrentState(world.ACTOR_STATIC, true);
          }

          break;
        case RIGHT:
          if (direction == DIR_RIGHT) {
            direction = DIR_STATIC;
            sprite.setCurrentState(world.ACTOR_STATIC, true);
          }

          break;
        case LEFT:
          if (direction == DIR_LEFT) {
            direction = DIR_STATIC;
            sprite.setCurrentState(world.ACTOR_STATIC, true);
          }

          break;
      }
    }

  }

  public void run()
  {
    while (live)
    {
      if (!isPause)
      {
        if (direction != DIR_STATIC)
        {
          switch (direction)
          {
            case DIR_UP:
              up();
              break;
            case DIR_DOWN:
              down();
              break;
            case DIR_LEFT:
              left();
              break;
            case DIR_RIGHT:
              right();
              break;
          }
        }
        try
        {
          Thread.sleep(50);
        }
        catch (InterruptedException ie)
        {
          System.out.println("error!");
        }
      }
      if (isPause)
      {
        try
        {
          Thread.sleep(1000);
        }
        catch (InterruptedException ie)
        {
          ie.printStackTrace();
        }
      }
    }
    state = STATE_END;
    //	System.out.println("s");
  }

  public void pause()
  {
    isPause = true;
  }

  public void resume()
  {
    isPause = false;
  }

  private void putBomb(int[][] map)
  {
    if (world.getBombNum() < bombNum)
    {
      int tileY = (posX + width / 2) / world.getTileWidth();
      int tileX = (posY + height / 2) / world.getTileHeight();
      if (world.canAcross(tileX, tileY, false))
      {
        world.addBomb(tileY * world.getTileHeight(), tileX * world.getTileWidth(),
                      power);
        //	System.out.println(tileX + " " + tileY);
        //	System.out.println(posX + " " + posY);
      }
    }
  }

  public int getWidth()
  {
    return width;
  }

  public int getHeight()
  {
    return height;
  }

  public boolean isLive()
  {
    return live;
  }

  public void setLive()
  {
    live = true;
  }

  public boolean isDisuse()
  {
    return disuse;
  }

  public void addPower()
  {
    if (power < MAX_POWER)
    {
      power++;
    }
  }

  public void addBombNum()
  {
    if (bombNum < MAX_BOMB_NUM)
    {
      bombNum++;
    }
  }
}