planecanvas.java

用J2ME写的射击游戏。玩法简单

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.util.Random;
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Font;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.rms.RecordStore;

/** 游戏界面MIDP1.0 */
public class PlaneCanvas extends Canvas implements Runnable {
	/** 构造方法 */
	public PlaneCanvas() {
		// 全屏是MIDP2.0开始的方法(不和要求)
		setFullScreenMode(true);
		// 导入游戏图片
		planeImg = new Image[9];
		pbImg = new Image[4];
		ebImg = new Image[4];
		try {
			logoImg = Image.createImage("/logo.png");
			menuImg = Image.createImage("/menu.png");
			loadSaveImg = Image.createImage("/load.png");
			helpImg = Image.createImage("/help.png");
			settingImg = Image.createImage("/setting.png");
			readImg = Image.createImage("/read.png");
			planeImg[0] = Image.createImage("/pp.png");
			planeImg[1] = Image.createImage("/boss1.png");
			planeImg[2] = Image.createImage("/boss2.png");
			planeImg[3] = Image.createImage("/boss3.png");
			for (int i = 0; i < 5; i++) {
				planeImg[i + 4] = Image.createImage("/ep" + i + ".png");
				if (i < 4) {
					pbImg[i] = Image.createImage("/pb" + i + ".png");
					ebImg[i] = Image.createImage("/eb" + i + ".png");
				}
			}
			blastImg = Image.createImage("/blast.png");
			winImg = Image.createImage("/win.png");
			failImg = Image.createImage("/fail.png");
			map1Img = Image.createImage("/map1.png");
			map2Img = Image.createImage("/map.png");
			bar0Img = Image.createImage("/status_bar0.png");
			bar1Img = Image.createImage("/status_bar1.png");
			offScreen = Image.createImage(width, height);
			off_g = offScreen.getGraphics();
			font = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD,
					Font.SIZE_LARGE);
		} catch (Exception e) {
		}
		// 数组初始化
		pp = new int[15];
		ep = new int[10][15];
		pb = new int[100][11];
		increaseDelay = new int[32][5];
		eb = new int[100][10];
		ppBlast = new int[10][4];
		blastArray = new int[60][4];
		barStr = new String[4];

		// 游戏状态、游戏速度、显示延迟变量初始化(不变了)
		gameState = GAME_LOGO; // 游戏logo显示
		sleepTime = 100; // 游戏速度默认为正常，即延迟100毫秒
		delay = 0;

		// 启动线程
		threadSwitch_Game = true;
		new Thread(this).start();
	}

	/** 线程run方法 */
	public void run() {
		try {
			while (threadSwitch_Game) {
				Thread.sleep(sleepTime);
				// 游戏状态监测
				gameStateControl();
				// 玩家飞机初始闪烁动画
				playerState();
				// 玩家无敌效果控制
				invincibility();
				// 玩家升级监测
				upgrade();
				// 右键菜单关闭，且左键暂停关闭
				if (!popMenuOpen & !leftPauseSwitch) {
					// 屏幕移动
					screenMove();
					// 添加敌人飞机
					addEP();
					// 敌人飞机移动
					EPMove();
					// 添加敌人炮弹
					addEB();
					// 添加玩家飞机炮弹、开火
					PPFire();
					// 敌人炮弹移动
					ebMove();
					// 玩家飞机连续移动
					PPMove(repeat);
					// 玩家炮弹移动
					PbMove();
					// 敌机同玩家炮弹的碰撞检测、处理、爆炸动画数据加载
					collidesWithEP();
					// 衍生弹计划生育
					planPb();
					// 玩家被击中的爆炸动画
					collidesWithPP();
					// 获得状态栏显示数值
					getBarSreDate();
				}
				// 绘制到脱机屏
				referDraw(off_g);
				repaint();
			}
		} catch (Exception e) {
		}
	}

	/** paint方法实现 */
	public void paint(Graphics g) {
		// 绘制脱机区域
		g.drawImage(offScreen, 0, 0, 0);
	}

	/** 叠加绘制或脱机屏幕绘制(所有需要绘制的都添加进来,按照层次添加) */
	private void referDraw(Graphics g) {
		switch (gameState) {
		case GAME_LOGO:
			g.drawImage(logoImg, 0, 0, Graphics.TOP | Graphics.LEFT);
			break;
		case GAME_SAVING:
			loadOrSave(g, SAVING);
			break;
		case GAME_LOADING:
			loadOrSave(g, LOADING);
			break;
		case GAME_HELP:
			g.drawImage(helpImg, 0, 0, Graphics.TOP | Graphics.LEFT);
			break;
		case GAME_SETTING:
			drawGameSetting(g);
			break;
		case GAME_READING:
			g.drawImage(readImg, 0, 0, Graphics.TOP | Graphics.LEFT);
			break;
		case GAME_MENU:
			drawGameMenu(g);
			break;
		case GAME_CONTINUE:
			// 绘制关卡logo和场景
			drawGateMap(g);
			// 绘制敌人炮弹
			drawEB(g);
			// 绘制玩家炮弹
			drawPB(g);
			// 绘制敌人飞机、生命条
			drawEP(g);
			// 绘制玩家飞机、生命条
			drawPP(g);
			// 绘制敌人飞机被击中的爆炸动画
			drawEPBlast(g);
			// 绘制玩家飞机被击中的爆炸动画
			drawPPBlast(g);
			// 绘制左软键继续游戏提示
			drawContinue(g);
			// 绘制游戏界面状态栏
			drawBar(g);
			// 绘制右软键菜单
			drawRightMenu(g);
			// 绘制右键菜单选项执行信息
			drawRightMenuRunInfo(g);
			break;
		case GAME_WIN:
			g.drawImage(winImg, 0, 0, Graphics.TOP | Graphics.LEFT);
			break;
		case GAME_OVER:
			drawGameFail(g);
			break;
		}
	}

	/**
	 * 按键事件方法
	 */
	public void keyPressed(int keyCode) {
		switch (gameState) {
		case GAME_MENU:
			// 主菜单界面按键
			mainMenuKeyPressed(keyCode);
			break;
		case GAME_HELP:
			// 帮助界面按键
			helpKeyPressed(keyCode);
			break;
		case GAME_SETTING:
			// 游戏设置界面按键
			settingKeyPressed(keyCode);
			break;
		case GAME_READING:
			// 游戏说明界面按键
			readKeyPressed(keyCode);
			break;
		case GAME_CONTINUE:
			// 游戏主界面按键
			gameKeyPressed(keyCode);
			break;
		case GAME_OVER:
			// 通关或游戏失败界面按键
			overKeyPressed(keyCode);
			break;
		}
	}

	/** 释放按键事件方法 */
	public void keyReleased(int keyCode) {
		int action = getGameAction(keyCode);
		switch (action) {
		case UP:
		case DOWN:
		case LEFT:
		case RIGHT:
			repeat = -1;
			break;
		}
	}

	/**
	 * 关卡初始化（变量初始化，系统资源释放）
	 * 
	 * @param gate关卡号
	 */
	private void init(int gate) {
		// 计时器
		delay = 0;
		times = 0;
		shotDelay = 0;
		// 开关
		unlock = false;
		popMenuOpen = false;
		leftPauseSwitch = false;
		// 其它
		planeSort = 0;
		popMenuIndex = 0;
		runRightMenuIndex = 0;
		mapX = 0;
		// 确认地图图片
		creatImg();
		switch (gate) {
		case 1:
			// 资源释放
			logoImg = null;
			clearArray();
			// 地图左上Y坐标（与卷屏相关）
			mapY = height - MAP1_HEIGHT;
			break;
		case 2:
			// 资源释放
			map1Img = null;
			clearArray();
			// 地图左上Y坐标（与卷屏相关）
			mapY = height - MAP2_HEIGHT;
			break;
		}
	}

	/** 关卡地图导入：避免多次反复进行游戏时出现因资源释放导致的bug */
	private void creatImg() {
		switch (gate) {
		case 1:
			if (map1Img == null) {
				try {
					map1Img = Image.createImage("/map1.png");
				} catch (Exception e) {
				}
			}
			break;
		case 2:
			if (map2Img == null) {
				try {
					map2Img = Image.createImage("/map.png");
				} catch (Exception e) {
				}
			}
			break;
		}
	}

	/** 游戏状态控制 */
	public void gameStateControl() {
		switch (gameState) {
		case GAME_LOGO:
			if (delay > 12) {
				gameState = GAME_MENU;
				delay = 0;
				break;
			}
			delay++;
			break;
		case GAME_MENU:
			delay++;
			break;
		case GAME_HELP:

			break;
		case GAME_SETTING:
			delay++;
			break;
		case GAME_READING:

			break;
		case GAME_CONTINUE:
			// 通过关卡状态控制游戏进程
			gateControl();
			break;
		case GAME_WIN:
			// 持续显示胜利logo画面
			if (delay > 15) {
				// 设置为主菜单状态
				gameState = GAME_MENU;
				// 资源清理，存储器刷新
				map2Img = null;
				clearArray();
				break;
			}
			delay++;
			break;
		case GAME_OVER:
			// 绘制方法中持续显示失败logo画面15
			// 选择是否重玩倒计时60,90就可卡点
			// 倒计时完毕回到主菜单
			if (delay > 90) {
				// 设置为主菜单状态
				gameState = GAME_MENU;
				// 资源清理，存储器刷新
				map2Img = null;
				clearArray();
				break;
			}
			delay++;
			break;
		case GAME_LOADING:
			if (record & delay == 1) {
				loadingGame();
			}
			if (delay > 49) {
				gameState = GAME_CONTINUE;
				delay = 0;
				break;
			}
			delay++;
			break;
		case GAME_SAVING:
			if (delay == 1) {
				savingGame();
			}
			if (delay > 49) {
				gameState = GAME_CONTINUE;
				delay = 0;
				break;
			}
			delay++;
			break;
		}
	}

	/** 关卡状态控制 */
	public void gateControl() {
		switch (gate) {
		case 1:
			switch (gateState) {
			case GATE_OPEN:
				// 为关卡logo显示延迟做准备
				delay++;
				if (delay > 15) {
					// 初始化并释放资源
					init(gate);
					// 创建玩家飞机
					createPP();
					delay = 0;
					// 转换游戏关卡状态
					gateState = GATE_CONTINUE;
				}
				break;
			case GATE_CONTINUE:
				// 如果时间到了还有一口气，则进入下一关
				if (times > GATEONE_TIME && pp[12] < LIFE) { 
					gate++;
					gateState = GATE_OPEN;
					// 数组数据清理
					clearArray();
				}
				break;
			case GATE_CLOSE:
				if (pp[12] > 0) {
					// 跳转到GAME_OVER显示失败logo(世界观之二：暂时失利不等于永远败溃！只有放弃才是GAME OVER！)
					gameState = GAME_OVER;
					delay = 0;
					times = 0;
					shotDelay = 0;
				}
				break;
			}
			break;
		case 2:
			switch (gateState) {
			case GATE_OPEN:
				delay++;
				if (delay > 15) {
					// 初始化并释放资源
					init(gate);
					// 创建玩家飞机
					createPP();
					delay = 0;
					// 转换游戏关卡状态
					gateState = GATE_CONTINUE;
				}
				break;
			case GATE_CONTINUE:
				// 如果时间到了还有一口气，便跳转到GAME_WIN状态，显示胜利logo(世界观之一：坚持到底也是胜利!)
				if (times > GATETWO_TIME && pp[12] < LIFE) {
					gameState = GAME_WIN;
				}
				break;
			case GATE_CLOSE: // 通关失败
				// 跳转到GAME_OVER显示失败logo(世界观之二：暂时失利不等于永远败溃！只有放弃才是GAME OVER！)
				gameState = GAME_OVER;
				// 数据存储数组刷新
				clearArray();
				break;
			}
			break;
		}
	}

	/** 储存游戏 */
	private void savingGame() {
		// 打开/创建记录集
		try {
			RecordStore rs = RecordStore.openRecordStore("saving", true);
			// 创建输出流对象
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			DataOutputStream dos = new DataOutputStream(baos);
			// 保存pp数组数据
			for (int i = 0; i < pp.length; i++) {
				dos.writeInt(pp[i]);
			}
			// 保存ep数组数据
			for (int i = 0; i < ep.length; i++) {
				for (int j = 0; j < ep[0].length; j++) {
					dos.writeInt(ep[i][j]);
				}
			}
			// 保存pb数组数据
			for (int i = 0; i < pb.length; i++) {
				for (int j = 0; j < pb[0].length; j++) {
					dos.writeInt(pb[i][j]);
				}
			}
			// 保存increaseDelay数组数据
			for (int i = 0; i < increaseDelay.length; i++) {
				for (int j = 0; j < increaseDelay[0].length; j++) {
					dos.writeInt(increaseDelay[i][j]);
				}
			}
			// 保存eb数组数据
			for (int i = 0; i < eb.length; i++) {
				for (int j = 0; j < eb[0].length; j++) {
					dos.writeInt(eb[i][j]);
				}
			}
			// 保存ppBlast数组数据
			for (int i = 0; i < ppBlast.length; i++) {
				for (int j = 0; j < ppBlast[0].length; j++) {
					dos.writeInt(ppBlast[i][j]);
				}
			}
			// 保存blastArray数组数据
			for (int i = 0; i < blastArray.length; i++) {
				for (int j = 0; j < blastArray[0].length; j++) {
					dos.writeInt(blastArray[i][j]);
				}
			}
			// 保存计时器
			dos.writeInt(delay);
			dos.writeInt(times);
			dos.writeInt(shotDelay);
			// 保存游戏关卡状态
			// dos.writeInt(gameState);//该状态会影响加载游戏界面显示
			dos.writeInt(gate);
			dos.writeInt(gateState);