playertank.java

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

package com.ipanel.games.tank;

import java.io.IOException;
import java.util.Enumeration;
import java.util.Random;
import java.util.Vector;

import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.Sprite;

public class PlayerTank implements bulletTarget, boomDrawer {

	private static Image imageTank = null;

	private Sprite spritePlayer = null;

	private final int FRAME_SEQUENCE_UP = 0;

	private final int FRAME_SEQUENCE_RIGHT = 1;

	private final int FRAME_SEQUENCE_DOWN = 2;

	private final int FRAME_SEQUENCE_LEFT = 3;

	private static Image imageBoom = null;

	public static int X_INIT = 150;

	public static int Y_INIT = 465;

	final int DIRECTION_UP = 1;

	final int DIRECTION_DOWN = 2;

	final int DIRECTION_LEFT = 3;

	final int DIRECTION_RIGHT = 4;

	private GameLayer layer = null;

	private int iDirection;

	private int X;

	private int Y;

	private final int STEP;

	private final int MAX_FIRE_NUMBER = 3;

	private int iFireNumber = 0;

	static {
		/*
		 * try { // imageTank = Image.createImage("/res/TankALL.png"); imageTank =
		 * Image.createImage("/res/Tank.png"); imageBoom =
		 * Image.createImage("/res/explosion13.png"); } catch (IOException e) {
		 * System.out.println("Exception when createImage in PlayerTank()!"); }
		 */
	}

	public PlayerTank(GameLayer layer) throws Exception {
		super();
		this.layer = layer;

		try {
			imageTank = Image.createImage("/res/TankAll.png");
			// imageTank = Image.createImage("/res/Tank.png");
			imageBoom = Image.createImage("/res/explosion13.png");
			spritePlayer = new Sprite(imageTank, 32, 32);
			// spritePlayer = new Sprite(imageTank);

			spritePlayer.setFrameSequence(new int[] { FRAME_SEQUENCE_UP,
					FRAME_SEQUENCE_RIGHT, FRAME_SEQUENCE_DOWN,
					FRAME_SEQUENCE_LEFT });

			X = X_INIT;
			Y = Y_INIT;
			Y = GameLayer.AREA_HEIGHT - spritePlayer.getHeight() - 1;
			spritePlayer.setPosition(X, Y);
			spritePlayer.setFrame(FRAME_SEQUENCE_UP);
			iDirection = DIRECTION_UP;

			STEP = 5;

			layer.registPlayerTank(this);
		} catch (IOException e) {
			layer.paintException("Exception when createImage in PlayerTank()!");
			throw e;
		}
	}

	void MoveUP() {
		/**
		 * 如果方向并非"UP"，不移动，只转向。
		 */
		if (iDirection == DIRECTION_UP) {
			Y -= STEP;
			spritePlayer.setPosition(X, Y);
			if (isUnAvailablePosition()) {
				Y += STEP;
				spritePlayer.setPosition(X, Y);
			}
		} else {
			int iLastDirection = iDirection;
			spritePlayer.setFrame(FRAME_SEQUENCE_UP);
			iDirection = DIRECTION_UP;
			adjustDirection(iLastDirection);
		}

	}

	void MoveDown() {
		/**
		 * 如果方向并非"DOWN"，不移动，只转向。
		 */
		if (iDirection == DIRECTION_DOWN) {
			Y += STEP;
			spritePlayer.setPosition(X, Y);
			if (isUnAvailablePosition()) {
				Y -= STEP;
				spritePlayer.setPosition(X, Y);
			}
		} else {
			int iLastDirection = iDirection;
			spritePlayer.setFrame(FRAME_SEQUENCE_DOWN);
			iDirection = DIRECTION_DOWN;
			adjustDirection(iLastDirection);
		}
	}

	void MoveLeft() {
		/**
		 * 如果方向并非"LEFT"，不移动，只转向。
		 */
		if (iDirection == DIRECTION_LEFT) {
			X -= STEP;
			spritePlayer.setPosition(X, Y);
			if (isUnAvailablePosition()) {
				X += STEP;
				spritePlayer.setPosition(X, Y);
			}
		} else {
			int iLastDirection = iDirection;
			spritePlayer.setFrame(FRAME_SEQUENCE_LEFT);
			iDirection = DIRECTION_LEFT;
			adjustDirection(iLastDirection);
		}
	}

	void MoveRight() {
		/**
		 * 如果方向并非"RIGHT"，不移动，只转向。
		 */
		if (iDirection == DIRECTION_RIGHT) {
			X += STEP;
			spritePlayer.setPosition(X, Y);
			if (isUnAvailablePosition()) {
				X -= STEP;
				spritePlayer.setPosition(X, Y);
			}
		} else {
			int iLastDirection = iDirection;
			spritePlayer.setFrame(FRAME_SEQUENCE_RIGHT);
			iDirection = DIRECTION_RIGHT;
			adjustDirection(iLastDirection);
		}
	}

	private void adjustDirection(int iLastDirection) {
		if (isUnAvailablePosition()) {
			iDirection = iLastDirection;
			switch (iDirection) {
			case DIRECTION_UP:
				spritePlayer.setFrame(FRAME_SEQUENCE_UP);
				break;
			case DIRECTION_DOWN:
				spritePlayer.setFrame(FRAME_SEQUENCE_DOWN);
				break;
			case DIRECTION_LEFT:
				spritePlayer.setFrame(FRAME_SEQUENCE_LEFT);
				break;
			case DIRECTION_RIGHT:
				spritePlayer.setFrame(FRAME_SEQUENCE_RIGHT);
				break;
			}
		}
	}

	private boolean isGameTankCollision() {
		Enumeration em = layer.getVGameTanks().elements();
		while (em.hasMoreElements()) {
			if (spritePlayer.collidesWith(((GameTank) em.nextElement())
					.getSpriteTank(), true)) {
				return true;
			}
		}
		return false;
	}

	private boolean isUnAvailablePosition() {
		return isLayerCollision() || GameLayer.isOutsideLayer(spritePlayer);
	}

	private boolean isLayerCollision() {
		return spritePlayer.collidesWith(layer.getTankLayer(), true);
	}

	void Fire() {
		synchronized (this) {
			if (iFireNumber < MAX_FIRE_NUMBER) {
				iFireNumber++;

				int X_Bullet = 0;
				int Y_Bullet = 0;
				switch (iDirection) {
				case DIRECTION_UP:
					X_Bullet = X + spritePlayer.getWidth() / 2 - 2;
					Y_Bullet = Y;
					break;
				case DIRECTION_DOWN:
					X_Bullet = X + spritePlayer.getWidth() / 2 - 2;
					Y_Bullet = Y + spritePlayer.getHeight();
					break;
				case DIRECTION_RIGHT:
					X_Bullet = X + spritePlayer.getWidth();
					Y_Bullet = Y + spritePlayer.getHeight() / 2 - 2;
					break;
				case DIRECTION_LEFT:
					X_Bullet = X;
					Y_Bullet = Y + spritePlayer.getHeight() / 2 - 2;
					break;
				}
				new PlayerBullet(layer, this, iDirection, X_Bullet, Y_Bullet);
			}
		}
	}

	void releaseFireNumber() {
		synchronized (this) {
			iFireNumber--;
		}
	}

	void paintPlayerTank(Graphics g) {
		spritePlayer.paint(g);
	}

	Sprite getSpritePlayer() {
		return spritePlayer;
	}

	public void hit() {
		registBoomDrawer();
		layer.unRegistPlayerTank(this);
		spritePlayer.setVisible(false);
		layer.nextPlayerTank();
	}

	/**
	 * Draw Boom规则： Drawer在GameLayer注册； GameLayer在paint()时间让Drawer完成drawBoom工作；
	 */
	private void registBoomDrawer() {
		layer.registMultipleDrawer(this);
	}

	public void drawBoom(Graphics graphic) {
		graphic.drawImage(imageBoom, X, Y, 0);
	}

}