blast.java~1~

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

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();
						}
					}
				}
			}
		}
	}
}