testlayermanager.java

简单介绍了一些图层和图层管理器的用法

import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.game.*;
import java.util.*;

public class TestLayerManager extends MIDlet implements CommandListener {
	private Command exitCommand, allCommand, aCommand0, aCommand1, aCommand2;

	private LayerCanvas canvas;

	private DemoTask task;

	private Timer timer;

	public TestLayerManager() {//创建命令，画布和定时器
		exitCommand = new Command("Exit", Command.EXIT, 1);
		allCommand = new Command("AllLayer", Command.SCREEN, 1);
		aCommand0 = new Command("Layer0", Command.SCREEN, 1);
		aCommand1 = new Command("Layer1", Command.SCREEN, 1);
		aCommand2 = new Command("FlowerLayer", Command.SCREEN, 1);
		canvas = new LayerCanvas();
		canvas.addCommand(allCommand);
		canvas.addCommand(exitCommand);
		canvas.addCommand(aCommand0);
		canvas.addCommand(aCommand1);
		canvas.addCommand(aCommand2);
		canvas.setCommandListener(this);
		timer = new Timer();
		task = new DemoTask(canvas);
	}

	protected void startApp() {//显示画布并开始游戏执行
		Display.getDisplay(this).setCurrent(canvas);
		timer.schedule(task, 0, 1000);
	}

	protected void pauseApp() {//暂停游戏执行
		timer.cancel();
	}

	protected void destroyApp(boolean p1) {
	}

	public void commandAction(Command c, Displayable d) {
		if (c == exitCommand) {
			destroyApp(false);
			notifyDestroyed();
		} else if (c == allCommand)
			canvas.setDrawMode(3);
		else if (c == aCommand0)
			canvas.setDrawMode(0);
		else if (c == aCommand1)
			canvas.setDrawMode(1);
		else if (c == aCommand2)
			canvas.setDrawMode(2);
	}

	public class LayerCanvas extends GameCanvas {
		private final int GAME_WIDTH = 130, GAME_HEIGHT = 60;

		private Graphics g;

		private int drawX, drawY;//图层显示的位置

		private int aniCounter = 0; //游戏计数器

		private LayerManager layerMan;

		private TiledLayer backLayer0, backLayer1, flowerLayer;

		private Image backImage0, backImage1, flowerImage;

		private int aniIndex = 0;

		private int drawMode = 3;

		private byte[][] backMap = //记录图层1的每个单元对应的图像块序号
		{ { 0, 0, 0, 4, 5, 0, 0, 0, 0, 0, 0, 0, 0 },
				{ 0, 0, 4, 3, 3, 5, 0, 0, 0, 0, 0, 0, 0 },
				{ 0, 4, 3, 3, 3, 3, 5, 0, 0, 0, 4, 5, 0 },
				{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
				{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 },
				{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } };

		//记录花朵图层上需要显示花朵的单元坐标
		private byte[][] flowerMap = { { 0, 0 }, { 1, 0 }, { 2, 0 } };

		public LayerCanvas() {
			super(true);
			g = getGraphics();//得到作图对象
			layerMan = new LayerManager();//创建图层管理对象
			try {//装入图像
				backImage0 = Image.createImage("/back0.png");
				backImage1 = Image.createImage("/back1.png");
				flowerImage = Image.createImage("/flower.png");
			} catch (Exception e) {
			}
			//创建背景图层0，显示天空
			backLayer0 = new TiledLayer(1, 1, backImage0, GAME_WIDTH, 30);
			//直接将图层显示的内容设置为序号的图像

            backLayer0.fillCells(0, 0, 1, 1, 1);
			//创建背景图层1，显示山和水
			backLayer1 = new TiledLayer(13, 6, backImage1, 10, 10);
			//创建动画分块
			aniIndex = backLayer1.createAnimatedTile(1);
			for (int y = 0; y < 5; y++) {//逐个设置每个单元格的图像，标记为0的单元格表示不处理
				for (int x = 0; x < 13; x++)
					backLayer1.fillCells(x, y, 1, 1, backMap[y][x]);
			}
			for (int x = 0; x < 13; x++)
				//用动画分块填充最下面一行
				backLayer1.setCell(x, 5, aniIndex);
			//创建花朵图层
			flowerLayer = new TiledLayer(3, 1, flowerImage, 10, 10);
			flowerLayer.move(70, 20);
			System.out.println("flowerLayer height " + flowerLayer.getHeight());
			for (int i = 0; i < 3; i++) {//将需要填充花朵的单元设置为序号为1的图像
				flowerLayer.fillCells(flowerMap[i][0], flowerMap[i][1], 1, 1, 1);
			}
			//将三个图层加入到图层管理对象中
			layerMan.append(flowerLayer);
			layerMan.append(backLayer1);
			layerMan.append(backLayer0);
          
            //计算游戏屏幕显示位置，显示在屏幕正中
			drawX = (getWidth() - GAME_WIDTH) / 2;
			drawY = (getHeight() - GAME_HEIGHT) / 2;
		}

		public void setDrawMode(int mode) {
			drawMode = mode;
			backLayer0.setVisible(false);
			backLayer1.setVisible(false);
			flowerLayer.setVisible(false);
			if (drawMode == 0)
				backLayer0.setVisible(true);
			else if (drawMode == 1)
				backLayer1.setVisible(true);
			else if (drawMode == 2)
				flowerLayer.setVisible(true);
			else {
				backLayer0.setVisible(true);
				backLayer1.setVisible(true);
				flowerLayer.setVisible(true);
			}
			g.setColor(0x00FFFFFF);//清除原有显示
			g.fillRect(drawX, drawY, GAME_WIDTH, GAME_HEIGHT);
		}

		public void DrawBack0() {//改变整个背景
			backLayer0.setCell(0, 0, aniCounter % 2 + 1);
		}

		public void DrawBack1() {//改变水为动态效果
			backLayer1.setAnimatedTile(aniIndex, aniCounter % 2 + 1);
		}

		public void DrawFlower() {//改变花为动画效果
			if (drawMode == 2) {//如果只显示本图层则填充屏幕为白色
				g.setColor(0x00FFFFFF);
				g.fillRect(drawX, drawY, GAME_WIDTH, GAME_HEIGHT);
			}
			for (int i = 0; i < 3; i++)
				flowerLayer.fillCells(flowerMap[i][0], flowerMap[i][1], 1, 1,
						aniCounter % 4 + 1);
		}


		//执行游戏功能
		public void Action() {
			aniCounter++;//增加计数器
			//在屏幕左上角显示计数器数字，表明Graphics 对象可以独立操作
			g.setColor(0x00FFFFFF);
			g.fillRect(0, 0, 60, 20);
			g.setColor(0x00000000);
            
            g.drawString(Integer.toString(aniCounter), 0, 0, Graphics.TOP
					| Graphics.LEFT);
			//处理每个图层的相关内容，处理的顺序对影响没有关系
			if (backLayer0.isVisible())
				DrawBack0();
			if (backLayer1.isVisible())
				DrawBack1();
			if (flowerLayer.isVisible())
				DrawFlower();
			//绘制图层
			layerMan.paint(g, drawX, drawY);
			//刷新屏幕
			flushGraphics();
		}
	}

	public class DemoTask extends TimerTask {
		private LayerCanvas canvas;

		public DemoTask(LayerCanvas can) {
			canvas = can;
		}

		public void run() {
			canvas.Action();
		}
	}
}