tetriscanvas.java

用J2ME开发的俄罗斯方块

package tetris;

import java.io.IOException;
import java.util.Random;
import javax.microedition.lcdui.Command;
import javax.microedition.lcdui.CommandListener;
import javax.microedition.lcdui.Displayable;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;

public class TetrisCanvas extends GameCanvas implements Runnable,
		CommandListener {

	private static final String RESTART = "restart";

	private static final String PAUSE = "pause";

	private static final String EXIT = "exit";

	private static final String START = "start";

	private static final int STATIC_BOX_COLOR = 0xf0f0f0;

	private static final int PREVIEW_COLOR = 0x990099;

	private static final int FRAME_COLOR = 0x00000f;

	private static final int BLACK = 0x000000;

	private static int DOWN_SPEEDUP = 8;

	private static final int GRID_BORDER_COLOR = 0x111111;

	private final static int SLEEP_TIME = 300;

	private static final int PREVIEW_GRID_HEIGHT = 6;

	private static final int PREVIEW_GRID_WIDTH = 6;

	private static final int GRID_HEIGHT = 10;

	private static final int GRID_WIDTH = 10;

	private final static int GAME_AREA_X = 15;

	private final static int GAME_AREA_Y = 12;

	private final static int GAME_AREA_HEIGHT = GRID_HEIGHT
			* (TetrisModel.ROW_COUNT - 2) + 1;

	private final static int GAME_AREA_WIDTH = GRID_WIDTH
			* (TetrisModel.COLUMN_COUNT - 2) + 1;

	private final static int PREVIEW_WINDOW_X = GAME_AREA_X + GAME_AREA_WIDTH
			+ 10;

	private final static int PREVIEW_WINDOW_Y = GAME_AREA_Y;

	private final static int PREVIEW_WINDOW_WIDTH = 30;

	private final static int PREVIEW_WINDOW_HEIGHT = 30;

	private final static int SCORE_X = PREVIEW_WINDOW_X + PREVIEW_WINDOW_WIDTH
			/ 2;

	private final static int SCORE_Y = PREVIEW_WINDOW_Y + PREVIEW_WINDOW_HEIGHT
			+ 10;

	private Score score;

	private Graphics g;

	private TetrisModel tetrisModel;

	private Image bgImage;

	private int width = 0;

	private int height = 0;

	private byte style = 0;

	private byte nextStyle = 0;

	private boolean running;

	private boolean pause;

	private Tetris tetris;

	private PlayerDemo player;

	public TetrisCanvas(boolean arg0, Tetris tetris) {
		super(arg0);
		player = new PlayerDemo();
		tetrisModel = new TetrisModel(player);
		score = new Score();
		g = getGraphics();
		width = getWidth();
		height = getHeight();
		running = false;
		try {
			bgImage = Image.createImage("/bg.png");
		} catch (IOException e) {
			e.printStackTrace();
		}
		initCommand();
		this.tetris = tetris;
	}

	private void initCommand() {
		addCommand(new Command(START, Command.OK, 0));
		addCommand(new Command(PAUSE, Command.OK, 1));
		addCommand(new Command(RESTART, Command.OK, 1));
		addCommand(new Command(EXIT, Command.OK, 1));
		setCommandListener(this);
	}

	public void start() {
		score.reset();
		running = true;
		player.playbg();
		Thread thread = new Thread(this);
		thread.start();
	}

	private void pause() {
		pause = !pause;
	}

	private void restart() {
		running = false;
		sleep(100);
		start();
	}

	private void exit() {
		tetris.exit();
	}

	private void disp() {
		tetris.disprms(score);
	}

	public void run() {
		tetrisModel.initPanel();
		setStyle();
		while (running) {
			if (!pause) {
				keyPressed();
				if (tetrisModel.isGameOver()) {
					gameOver();
					return;
				} else {
					going();
				}
			} else {
				sleep(2 * SLEEP_TIME);
			}
		}
		if (score.getScore() > 300) {
			DOWN_SPEEDUP = 10;
		} else if (score.getScore() > 800) {
			DOWN_SPEEDUP = 12;
		} else if (score.getScore() > 1400) {
			DOWN_SPEEDUP = 14;
		}
	}

	private void going() {
		if (tetrisModel.canDown()) {
			tetrisModel.down();
		} else {
			tetrisModel.fallBoxToGround();
			score.add(tetrisModel.handleFullRow());
			setStyle();
			if (tetrisModel.handleFullRow() != 0) {
				player.playdispear();
			}
		}
		draw();
		sleep(SLEEP_TIME);
	}

	private void draw() {
		drawBackground();
		drawFrame();
		drawGamePanel();
		drawPreview();
		drawScore();
		flushGraphics();
	}

	private void drawScore() {
		g.setColor(BLACK);
		g.drawString("" + score.getScore(), SCORE_X, SCORE_Y, Graphics.TOP
				| Graphics.HCENTER);
	}

	private void keyPressed() {
		int keyState = getKeyStates();
		left(keyState);
		right(keyState);
		down(keyState);
		up(keyState);
	}

	private void up(int keyState) {
		if ((keyState & UP_PRESSED) != 0) {
			if (tetrisModel.isTransformable()) {
				tetrisModel.transform();
			}
		}
	}

	private void down(int keyState) {
		if ((keyState & DOWN_PRESSED) != 0) {
			for (int i = 0; i < DOWN_SPEEDUP; i++) {
				if (tetrisModel.canDown()) {
					tetrisModel.down();
				} else {
					break;
				}
			}
		}
	}

	private void right(int keyState) {
		if ((keyState & RIGHT_PRESSED) != 0) {
			if (tetrisModel.canRight()) {
				tetrisModel.right();
			}
		}
	}

	private void left(int keyState) {
		if ((keyState & LEFT_PRESSED) != 0) {
			if (tetrisModel.canLeft()) {
				tetrisModel.left();
			}
		}
	}

	private void sleep(int time) {
		try {
			Thread.sleep(time);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	private void setStyle() {
		Random random = new Random();
		style = nextStyle;
		nextStyle = (byte) random.nextInt(TetrisModel.STYLE_COUNT);
		tetrisModel.setCurrentBoxInfo(style);
	}

	private void drawGamePanel() {
		for (int row = 1; row <= TetrisModel.ROW_COUNT - 2; row++) {
			for (int column = 1; column <= TetrisModel.COLUMN_COUNT - 2; column++) {
				drawStaticPanel(row, column);
				drawDynamicPanel(row, column);
			}
		}
	}

	private void drawStaticPanel(int row, int column) {
		if (tetrisModel.staticPanel[row][column] > 0) {
			drawGridBorder(row, column);
			g.setColor(STATIC_BOX_COLOR);
			drawGrid(row, column);
		}
	}

	private void drawDynamicPanel(int row, int column) {
		byte styleIndex = tetrisModel.dynamicPanel[row][column];
		if (styleIndex > 0) {
			setStyleColor(styleIndex);
			drawGrid(row, column);
			drawGridBorder(row, column);
		}
	}

	private void drawGrid(int row, int column) {
		g.fillRect(GAME_AREA_X + (column - 1) * GRID_WIDTH + 1, GAME_AREA_Y
				+ (row - 1) * GRID_HEIGHT + 1, GRID_WIDTH - 1, GRID_HEIGHT - 1);
	}

	private void drawGridBorder(int row, int column) {
		g.setColor(GRID_BORDER_COLOR);
		g.drawRect(GAME_AREA_X + (column - 1) * GRID_WIDTH, GAME_AREA_Y
				+ (row - 1) * GRID_HEIGHT, GRID_WIDTH, GRID_HEIGHT);
	}

	private void setStyleColor(int style) {
		switch (style) {
		case 1:
			g.setColor(0x99cc00);
			break;
		case 2:
			g.setColor(0x007f7f);
			break;
		case 3:
			g.setColor(0x800080);
			break;
		case 4:
			g.setColor(0x808000);
			break;
		case 5:
			g.setColor(0x008000);
			break;
		case 6:
			g.setColor(0x800000);
			break;
		case 7:
			g.setColor(0x707070);
			break;
		default:
			g.setColor(0x700000);
		}
	}

	private void drawPreview() {
		int offsetX = PREVIEW_WINDOW_X + PREVIEW_WINDOW_WIDTH / 3;
		int offsetY = PREVIEW_WINDOW_Y + PREVIEW_WINDOW_HEIGHT / 3;
		int nextBoxIndex = tetrisModel.getBoxIndex(nextStyle);
		for (int i = 0; i < TetrisModel.POINT_COUNT_IN_BOX; i++) {
			int x = tetrisModel.allBox[nextBoxIndex].cells[i][0];
			int y = tetrisModel.allBox[nextBoxIndex].cells[i][1];
			x = offsetX + x * PREVIEW_GRID_WIDTH;
			y = offsetY + y * PREVIEW_GRID_HEIGHT;
			drawPreviewGrid(x, y);
		}
	}

	private void drawPreviewGrid(int x, int y) {
		g.setColor(BLACK);
		g.drawRect(x, y, PREVIEW_GRID_WIDTH, PREVIEW_GRID_HEIGHT);
		g.setColor(PREVIEW_COLOR);
		g.fillRect(x + 1, y + 1, PREVIEW_GRID_WIDTH - 1,
				PREVIEW_GRID_HEIGHT - 1);
	}

	private void drawFrame() {
		g.setColor(FRAME_COLOR);
		g.drawRect(GAME_AREA_X, GAME_AREA_Y, GAME_AREA_WIDTH, GAME_AREA_HEIGHT);
		g.drawRect(PREVIEW_WINDOW_X, PREVIEW_WINDOW_Y, PREVIEW_WINDOW_WIDTH,
				PREVIEW_WINDOW_HEIGHT);
	}

	private void drawBackground() {
		g.drawImage(bgImage, 0, 0, Graphics.TOP | Graphics.LEFT);
	}

	private void gameOver() {
		running = false;
		drawBackground();
		g.setColor(BLACK);
		g.drawString("GAME OVER", width / 2, height / 2, Graphics.HCENTER
				| Graphics.BOTTOM);
		flushGraphics();
		sleep(500);
		disp();
	}

	public void commandAction(Command c, Displayable arg1) {
		String cmd = c.getLabel();
		if (cmd.equals(PAUSE)) {
			pause();
		} else if (cmd.equals(RESTART)) {
			restart();
		} else if (cmd.equals(EXIT)) {
			exit();
		} else if (cmd.equals(START)) {
			start();
		}
	}
}