blast.java

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

import javax.microedition.lcdui.Graphics;

public class Blast {
  private static final int PER_S_CYC = 20;

//	private static final int MAX_POWER = 10;

  private static final int SCAN_UP = 1;
  private static final int SCAN_DOWN = 2;
  private static final int SCAN_RIGHT = 3;
  private static final int SCAN_LEFT = 4;

  private int posX;
  private int posY;
  private int power;
  private World world;
  private int remainCyc;
  private Sprite blast_mid;
  private Sprite blast_up;
  private Sprite blast_down;
  private Sprite blast_right;
  private Sprite blast_left;
  private Sprite blast_h;
  private Sprite blast_v;
  private boolean live;
  private int tileWidth;
  private int tileHeight;
  private int[][] destroy_up;
  private int[][] destroy_down;
  private int[][] destroy_left;
  private int[][] destroy_right;

  public Blast(World world, int x, int y, int power)
  {
    posX = x;
    posY = y;
    this.power = power;
    this.world = world;
    remainCyc = 10;
    ImageSet imageSet = world.getImageSet();
    blast_mid = new Sprite(imageSet, world.BLAST_MID, 0);
    blast_up = new Sprite(imageSet, world.BLAST_UP, 0);
    blast_right = new Sprite(imageSet, world.BLAST_RIGHT, 0);
    blast_down = new Sprite(imageSet, world.BLAST_DOWN, 0);
    blast_left = new Sprite(imageSet, world.BLAST_LEFT, 0);
    if (power > 1)
    {
      blast_h = new Sprite(imageSet, world.BLAST_H, 0);
      blast_v = new Sprite(imageSet, world.BLAST_V, 0);
    }
    live = true;
    tileWidth = world.getTileWidth();
    tileHeight = world.getTileHeight();
    destroy_up = getDestroyRegion(SCAN_UP);
    destroy_down = getDestroyRegion(SCAN_DOWN);
    destroy_right = getDestroyRegion(SCAN_RIGHT);
    destroy_left = getDestroyRegion(SCAN_LEFT);
  }

  private int[][] initArray(int x, int y)
  { //init -1
    int[][] result = new int[x][y];
    for (int i = 0; i < result.length; i++)
    {
      for (int j = 0; j < result[i].length; j++)
      {
        result[i][j] = -1;
      }
    }
    return result;
  }

  public void cycle()
  {
    if (remainCyc <= 0)
    {
      live = false;
    }
    else
    {
      remainCyc--;
    }

    blast_up.cycle();
    blast_down.cycle();
    blast_right.cycle();
    blast_left.cycle();
    blast_mid.cycle();
    if (power > 1)
    {
      blast_v.cycle();
      blast_h.cycle();
    }
    killActor(world.getActor());
    killEnemy(world.getEnemyArray());
  }

  private int[][] getDestroyRegion(int dir)
  {
    int tileWidth = world.getTileWidth();
    int tileHeight = world.getTileHeight();
    int[][] bufMap = world.getMap();
    int tileX = posY / tileHeight;
    int tileY = posX / tileWidth;
    int buf = -1;
    int[][] result = initArray(power + 1, 2);
    switch (dir)
    {
      case SCAN_UP: //up
        for (int i = 1; i <= power; i++)
        {
          buf = bufMap[tileX - i][tileY];
          if (world.canAcross(tileX - i, tileY, false))
          {
            result[i][0] = tileY * tileWidth;
            result[i][1] = (tileX - i) * tileHeight;
            result[0][0] = i;
          }
          else if (buf == World.TILE2)
          {
            result[i][0] = tileY * tileWidth;
            result[i][1] = (tileX - i) * tileHeight;
            result[0][0] = i;
            world.destroy(tileX - i, tileY);
            break;
          }
          else if (!world.canAcross(tileX - i, tileY, false) &&
                   buf != World.TILE2)
          {
            break;
          }
        }
        break;
      case SCAN_DOWN: //down
        for (int i = 1; i <= power; i++)
        {
          buf = bufMap[tileX + i][tileY];
          if (world.canAcross(tileX + i, tileY, false))
          {
            result[i][0] = tileY * tileWidth;
            result[i][1] = (tileX + i) * tileHeight;
            result[0][0] = i;

          }
          else if (buf == World.TILE2)
          {
            result[i][0] = tileY * tileWidth;
            result[i][1] = (tileX + i) * tileHeight;
            result[0][0] = i;
            world.destroy(tileX + i, tileY);
            break;
          }
          else if (!world.canAcross(tileX + i, tileY, false) &&
                   buf != World.TILE2)
          {
            break;
          }
        }
        break;
      case SCAN_LEFT: //left
        for (int i = 1; i <= power; i++)
        {
          buf = bufMap[tileX][tileY - i];
          if (world.canAcross(tileX, tileY - i, false))
          {
            result[i][0] = (tileY - i) * tileWidth;
            result[i][1] = tileX * tileHeight;
            result[0][0] = i;

          }
          else if (buf == World.TILE2)
          {
            result[i][0] = (tileY - i) * tileWidth;
            result[i][1] = tileX * tileHeight;
            result[0][0] = i;
            world.destroy(tileX, tileY - i);
            break;
          }
          else if (!world.canAcross(tileX, tileY - i, false) &&
                   buf != World.TILE2)
          {
            break;
          }
        }
        break;
      case SCAN_RIGHT: //right
        for (int i = 1; i <= power; i++)
        {
          buf = bufMap[tileX][tileY + i];
          if (world.canAcross(tileX, tileY + i, false))
          {
            result[i][0] = (tileY + i) * tileWidth;
            result[i][1] = tileX * tileHeight;
            result[0][0] = i;

          }
          else if (buf == World.TILE2)
          {
            result[i][0] = (tileY + i) * tileWidth;
            result[i][1] = tileX * tileHeight;
            result[0][0] = i;
            world.destroy(tileX, tileY + i);
            break;
          }
          else if (!world.canAcross(tileX, tileY + i, false) &&
                   buf != World.TILE2)
          {
            break;
          }
        }
        break;
    }
    return result;
  }

  public void render(Graphics gra)
  {
    int viewX = world.getViewX();
    int viewY = world.getViewY();
    if (live)
    {
      /*	blast_mid.draw(gra,posX - viewX,posY - viewY
               ,Graphics.TOP|Graphics.LEFT);
       blast_up.draw(gra,posX - viewX,posY - tileHeight - viewY
               ,Graphics.TOP|Graphics.LEFT);
       blast_down.draw(gra,posX - viewX,posY + tileHeight - viewY
               ,Graphics.TOP|Graphics.LEFT);
       blast_right.draw(gra,posX + tileWidth - viewX,posY - viewY
               ,Graphics.TOP|Graphics.LEFT);
       blast_left.draw(gra,posX - tileWidth - viewX,posY - viewY
               ,Graphics.TOP|Graphics.LEFT);
       */
      blast_mid.draw(gra, posX - viewX, posY - viewY
                     , Graphics.TOP | Graphics.LEFT);
      //up
      for (int i = 1; i < destroy_up.length; i++)
      {
        if (destroy_up[0][0] == -1)
        { //说明该数组为空，无需渲染
          break;
        }
        if (destroy_up[i][0] >= 0 && destroy_up[i][1] >= 0)
        {
          if (i == destroy_up[0][0])
          {
            blast_up.draw(gra, destroy_up[i][0] - viewX
                          , destroy_up[i][1] - viewY
                          , Graphics.TOP | Graphics.LEFT);
            break;
          }
          else
          {
            blast_v.draw(gra, destroy_up[i][0] - viewX
                         , destroy_up[i][1] - viewY
                         , Graphics.TOP | Graphics.LEFT);
          }
        }
      }
      //down
      for (int i = 1; i < destroy_down.length; i++)
      {
        if (destroy_down[0][0] == -1)
        { //说明该数组为空，无需渲染
          break;
        }
        if (i == destroy_down[0][0])
        {
          blast_down.draw(gra, destroy_down[i][0] - viewX
                          , destroy_down[i][1] - viewY
                          , Graphics.TOP | Graphics.LEFT);
          break;
        }
        else
        {
          blast_v.draw(gra, destroy_down[i][0] - viewX
                       , destroy_down[i][1] - viewY
                       , Graphics.TOP | Graphics.LEFT);
        }
      }
      //right
      for (int i = 1; i < destroy_right.length; i++)
      {
        if (destroy_right[0][0] == -1) { //说明该数组为空，无需渲染
          break;
        }
        if (i == destroy_right[0][0])
        {
          blast_right.draw(gra, destroy_right[i][0] - viewX
                           , destroy_right[i][1] - viewY
                           , Graphics.TOP | Graphics.LEFT);
          break;
        }
        else
        {
          blast_h.draw(gra, destroy_right[i][0] - viewX
                       , destroy_right[i][1] - viewY
                       , Graphics.TOP | Graphics.LEFT);
        }
      }
      //left
      for (int i = 1; i < destroy_up.length; i++)
      {
        if (destroy_left[0][0] == -1)
        { //说明该数组为空，无需渲染
          break;
        }
        if (i == destroy_left[0][0])
        {
          blast_left.draw(gra, destroy_left[i][0] - viewX
                          , destroy_left[i][1] - viewY
                          , Graphics.TOP | Graphics.LEFT);
          break;
        }
        else
        {
          blast_h.draw(gra, destroy_left[i][0] - viewX
                       , destroy_left[i][1] - viewY
                       , Graphics.TOP | Graphics.LEFT);
        }
      }
    }
  }

  public boolean isLive()
  {
    return live;
  }

  public void killActor(Actor actor)
  {
    int x = -1;
    int y = -1;
    int tileX = (actor.getY() + actor.getHeight() / 2) / world.getTileHeight();
    int tileY = (actor.getX() + actor.getWidth() / 2) / world.getTileWidth();

    x = posY / world.getTileHeight();
    y = posX / world.getTileWidth();
    if (x == tileX && y == tileY)
    {
      actor.dead();
    }
    for (int i = 1; i < destroy_up.length; i++)
    {
      if (destroy_up[i][0] >= 0 && destroy_up[i][1] >= 0)
      {
        x = destroy_up[i][1] / world.getTileHeight();
        y = destroy_up[i][0] / world.getTileWidth();
        if (tileX == x && tileY == y)
        {
          actor.dead();
        }
      }
    }
    for (int i = 1; i < destroy_down.length; i++)
    {
      if (destroy_down[i][0] >= 0 && destroy_down[i][1] >= 0)
      {
        x = destroy_down[i][1] / world.getTileHeight();
        y = destroy_down[i][0] / world.getTileWidth();
        if (tileX == x && tileY == y)
        {
          actor.dead();
        }
      }
    }
    for (int i = 1; i < destroy_right.length; i++)
    {
      if (destroy_right[i][0] >= 0 && destroy_right[i][1] >= 0)
      {
        x = destroy_right[i][1] / world.getTileHeight();
        y = destroy_right[i][0] / world.getTileWidth();
        if (tileX == x && tileY == y)
        {
          actor.dead();
        }
      }
    }
    for (int i = 1; i < destroy_left.length; i++)
    {
      if (destroy_left[i][0] >= 0 && destroy_left[i][1] >= 0)
      {
        x = destroy_left[i][1] / world.getTileHeight();
        y = destroy_left[i][0] / world.getTileWidth();
        if (tileX == x && tileY == y)
        {
          actor.dead();
        }
      }
    }
  }

  public void killEnemy(Enemy[] enemyArray)
  {
    for (int j = 0; j < enemyArray.length; j++)
    {
      if (enemyArray[j] != null)
      {
        Enemy enemy = enemyArray[j];
        int x = -1;
        int y = -1;
        int tileX = (enemy.getY() + enemy.getHeight() / 2) /
            world.getTileHeight();
        int tileY = (enemy.getX() + enemy.getWidth() / 2) / world.getTileWidth();
        for (int i = 1; i < destroy_up.length; i++)
        {
          if (destroy_up[i][0] >= 0 && destroy_up[i][1] >= 0)
          {
            x = destroy_up[i][1] / world.getTileHeight();
            y = destroy_up[i][0] / world.getTileWidth();
            if (tileX == x && tileY == y && enemy.isLive())
            {
              enemy.dead();
            }
          }
        }
        for (int i = 1; i < destroy_down.length; i++)
        {
          if (destroy_down[i][0] >= 0 && destroy_down[i][1] >= 0)
          {
            x = destroy_down[i][1] / world.getTileHeight();
            y = destroy_down[i][0] / world.getTileWidth();
            if (tileX == x && tileY == y && enemy.isLive())
            {
              enemy.dead();
            }
          }
        }
        for (int i = 1; i < destroy_right.length; i++)
        {
          if (destroy_right[i][0] >= 0 && destroy_right[i][1] >= 0)
          {
            x = destroy_right[i][1] / world.getTileHeight();
            y = destroy_right[i][0] / world.getTileWidth();
            if (tileX == x && tileY == y && enemy.isLive())
            {
              enemy.dead();
            }
          }
        }
        for (int i = 1; i < destroy_left.length; i++)
        {
          if (destroy_left[i][0] >= 0 && destroy_left[i][1] >= 0)
          {
            x = destroy_left[i][1] / world.getTileHeight();
            y = destroy_left[i][0] / world.getTileWidth();
            if (tileX == x && tileY == y && enemy.isLive())
            {
              enemy.dead();
            }
          }
        }
      }
    }
  }
}