iptankgamecanvas.java

一个非常不错的J2ME坦克大战的游戏,可以在机顶盒上实际运行.

package com.ipanel.games.tank;

import java.util.Timer;
import java.util.TimerTask;

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.lcdui.game.Sprite;
import javax.microedition.midlet.MIDlet;

public class IPTankGameCanvas extends GameCanvas {

	private MIDlet midlet = null;

	private final Graphics graphic = getGraphics();

	private final GameLayer gameLayer;

	private Timer timer = new Timer();

	private PlayerTank player = null;

	private GameTankManager gameTankManager = null;

	private PlayerTankManager playerTankManager = null;

	/**
	 * 背景为黑色。
	 */
	private final int BACKGROUND = 0x00000000;

	private int GAME_STATUS = 0;

	private final int GAME_STATUS_RUNNING = 1;

	private final int GAME_STATUS_PAUSE = 2;

	private int X_EXCEPTION = 150;

	private int Y_EXCEPTION = 0;

	/**
	 * 此boolean也是仅翻转一次，所以是可以接受的。
	 */
	private boolean isException = false;

	private final int GAME_STATUS_EXCEPTION = -100;

	private final int PAINT_INTERVAL = 50 ;

	public IPTankGameCanvas(boolean shouldBeFalse) {
		super(shouldBeFalse);

		gameLayer = new GameLayer(this);

		try {
			work();
		} catch (Exception e) {
			paintException("Exception in IPTankGameCanvas.work()!");
		}
	}

	public IPTankGameCanvas(MIDlet midlet, boolean shouldBeFalse) {
		this(shouldBeFalse);
		this.midlet = midlet;
	}

	/**
	 * work()本身执行且仅执行一次。
	 */
	void work() throws Exception {

		try {
			GAME_STATUS = GAME_STATUS_RUNNING;
			playerTankManager = new PlayerTankManager(gameLayer);
			player = playerTankManager.getCurrentPlayer();
			gameTankManager = new GameTankManager(gameLayer);
			//new GameTank(gameLayer, new IPTankRandom().next(16));
		} catch (Exception e) {
			throw e;
		}
		timer.schedule(new GameTask(), 0, PAINT_INTERVAL);

	}

	class GameTask extends TimerTask {
		public void run() {
			try {
				Thread.currentThread().sleep(50);
			} catch (InterruptedException e) {
				paintException("Exception from Thread.sleep()!");
			}
			synchronized (gameLayer) {
				if (!isException) {
					/**
					 * clear后paint各个objects，然后flush。
					 */
					graphic.setColor(BACKGROUND);
					graphic.fillRect(0, 0, getWidth(), getHeight());
					drawBorder();

					gameLayer.paintLayer(graphic);
				}
				flushGraphics();
			}
		}
	}

	protected void keyPressed(int keyCode) {

		int iAction = getGameAction(keyCode);

		/**
		 * 因为gameLayer是synchronized涉及的类共同"知道"的引用，所以用作synchronized的介质。
		 * 此时，其它相关的事务，应该配合使用synchronized。
		 */
		synchronized (gameLayer) {

			switch (GAME_STATUS) {
			case GAME_STATUS_RUNNING:
				if (null != player) {

					switch (iAction) {
					case UP:
						player.MoveUP();
						break;
					case DOWN:
						player.MoveDown();
						break;
					case LEFT:
						player.MoveLeft();
						break;
					case RIGHT:
						player.MoveRight();
						break;
					case FIRE:
						player.Fire();
						break;
					case 0:
						pauseGame();
						break;
					}
				}
				break;
			case GAME_STATUS_PAUSE:
				/**
				 * Pause的时候只响应iAction=0。
				 */
				switch (iAction) {
				case 0:
					restartGame();
					break;
				}
				break;
			case GAME_STATUS_EXCEPTION:
				/**
				 * 不做任何响应。
				 */
				break;
			}
		}
	}

	protected void keyRepeated(int keyCode) {
		int iAction = getGameAction(keyCode);

		switch (iAction) {
		case UP:
			player.MoveUP();
			break;
		case LEFT:
			player.MoveLeft();
			break;
		case FIRE:
			player.Fire();
			break;
		}

	}

	/**
	 * 以下所有pause/restart的代码的运行时刻执行，都是在ketPressed()线程的synchronized之下进行的。
	 */
	private void pauseGame() {
		GAME_STATUS = GAME_STATUS_PAUSE;
		pauseGameCanvas();
		gameTankManager.pauseWork();
		gameLayer.pauseGame();
	}

	private void restartGame() {
		GAME_STATUS = GAME_STATUS_RUNNING;
		new Thread() {
			public void run() {
				gameTankManager.restartWork();
			}
		}.start();
		new Thread() {
			public void run() {
				gameLayer.restartGame();
			}
		}.start();
		new Thread() {
			public void run() {
				restartGameCanvas();
			}
		}.start();
	}

	private void pauseGameCanvas() {
		timer.cancel();
	}

	private void restartGameCanvas() {
		timer = new Timer();
		timer.schedule(new GameTask(), 0, PAINT_INTERVAL);
	}

	void nextPlayerTank() {
		player = playerTankManager.getCurrentPlayer();
	}

	/**
	 * 画出Game AREA的边界。
	 */
	void drawBorder() {
		graphic.setColor(0, 128, 0);
		graphic.drawRect(GameLayer.AREA_UP_LEFT_X, GameLayer.AREA_UP_LEFT_Y,
				GameLayer.AREA_WIDTH, GameLayer.AREA_HEIGHT);
	}

	void paintException(String strMessage) {

		/**
		 * 在且仅在第一个Exception throwed的时候clear页面。
		 */
		if (GAME_STATUS != GAME_STATUS_EXCEPTION) {
			graphic.setColor(0xffffffff);
			graphic.fillRect(0, 0, getWidth(), getHeight());
			drawBorder();
			GAME_STATUS = GAME_STATUS_EXCEPTION;
		}

		Y_EXCEPTION += 15;
		graphic.drawString(strMessage, X_EXCEPTION, Y_EXCEPTION, 0);
	}

}