Java飞机大战游戏设计与实现

Marlboro

发布日期: 2018-11-04 23:00:52 浏览量: 2987
评分:
star star star star star star star star star star
*转载请注明来自write-bug.com

1 概述

1.1 项目简介

本次Java课程设计是做一个飞机大战的游戏,应用Swing编程,完成一个界面简洁流畅、游戏方式简单,玩起来易于上手的桌面游戏。该飞机大战项目运用的主要技术即是Swing编程中的一些窗口类库、事件监听以及贴图技术。

1.2 实训功能说明

1.2.1 基本功能

  • 通过键盘,方向键和ASWD键可控制战机的位置,空格键和鼠标左键发射子弹

  • 界面中敌机出现的位置,以及敌机和Boss炸弹的发射均为随机的,敌机与敌机炸弹、Boss炸弹均具有一定的速度,且随着关卡难度的增大,数量和速度均随着关卡数增加而增加

  • 对于随机产生的敌机和敌机炸弹,若超过矩形区域,则释放该对象

  • 添加碰撞效果,包括战机子弹打中敌机爆炸、敌机炸弹打中战机爆炸、战机与敌机相撞爆炸、战机子弹与敌机炸弹相撞爆炸、战机子弹打中Boss、战机与Boss碰撞以及战机吃到血包七种碰撞效果。且碰撞发生后子弹、炸弹、血包均消失,战机生命值减一,敌机和Boss生命值减少当前战机炮弹威力的生命值,若敌机或Boss生命值归零,则删除敌机或Boss

  • 血包:随着关卡游戏进程的进行,会出现一定量的血包供战机补给生命值,血包会在客户区矩形框内运动,10秒后消失;若战机在10秒内吃到血包,则会增加5点生命值知道生命值上限

  • 每关中战机有三条命,每条命10点生命值,生命使用完后,会进入GameOver界面显示得分数,并提供重新开始游戏和退出功能

  • 游戏提供10个关卡,每个关卡需要打死相应关卡的敌机数量才能进入Boss模式,打败Boss之后将会进入下一关。10关通关后,显示通关界面,并提供重新开始游戏和退出游戏的功能选项

  • 暂停功能:游戏进行过程中按下Z键可进入暂停模式,再按Z则返回游戏

  • 无敌模式:游戏进行过程中按下Y键可进入无敌模式,再按Y则返回正常游戏。该模式下战机生命值不会减少,可供测试使用

  • 魔法值:游戏进行过程中,战机魔法值会随着时间递增到上限10,魔法值供战机道具功能的使用,过一个关卡魔法值不清零

  • 战机大招:当战机魔法值为10满状态时,按下X键消耗所有魔法值可发动大招,对屏幕中的敌机进行清屏,Boss扣50点血量

  • 防护罩:当魔法值不为0时,按下C键可打开防护罩道具,该状态下战机处于无敌状态,不会损失生命值,但魔法值会随着防护罩开启慢慢降低

  • 战机升级功能:战机子弹单个威力为1,在魔法值不为0时,按下V键开启升级战机模式,战机图标变为动画,子弹威力变成两倍。(若同时开启防护罩和战机升级,则魔法值递减速度翻倍)

1.2.2 附加功能

  • 为游戏界面每个关卡添加了滚动背景图片和背景音乐,并在敌机发送炮弹、战机发射子弹、战机击中敌机、敌机击中战机、战机敌机相撞、敌机战机子弹相撞、战机吃到血包、战机大招、战机升级、战机防护罩、游戏结束时均添加了音效

  • 为美化游戏界面,采用了一部分全民飞机大战图标,并添加了爆炸动画和升级战机动画特效,背景音乐采用微信飞机大战背景音乐和相关特效音效

  • 为游戏设置了不同的关卡,每个关卡难度不同,敌机与敌机炸弹的速度随着关卡增大而加快,进入第五关以后敌机从上下方均会随机出现,且随机发射炸弹

  • 前五关卡敌机从上方飞出,速度一定,战机每打掉一架敌机则增加一分,当战机得分超过该关卡所需分数(和关卡数相关)则可进入Boss模式,打败Boss进入下一关;进入第六关以后,敌机分别从上下两方飞出。随着关卡数增加,敌机数量增加,速度增快,敌机炮弹数量和速度也相应增加,进入Boss所需分数增加,Boss生命值和火力也随着关卡数的增加而增加,游戏难度陡然直升

  • 游戏界面中显示当前状态下的关卡数、当前命数、当前得分、战机血条、战机魔法条、无敌模式提醒和战机道具提醒,Boss模式下还有Boss血条

  • 增加了鼠标控制战机位置这一效果,战绩的位置随着鼠标的移动而移动,并且点击鼠标左键可使得战机发射子弹

  • 进入游戏先进入欢迎界面,欢迎界面中显示游戏使用说明,点击鼠标左键和空格键开始游戏。游戏过程中战机命数使用完、通关均有相应界面进行提醒,用户可选择重新开始游戏或退出游戏

2 相关技术

2.1 Timer定时器技术

本次项目采用了Java的Timer定时器和TimerTask任务,Timer周期性地在每经过一个指定的时间间隔后就通知TimerTask一次,让TimerTask按照Timer设定的周期循环地执行任务。本程序中使用多个定时器,分别控制不同的功能,分别是屏幕刷新Timer,敌机产生Timer,魔法值变化Timer,血包生命周期Timer。

2.2 透明贴图实现技术

绘制透明位图的关键就是创建一个“掩码”位图(mask bitmap),这个“掩码”位图是一个单色位图,它是位图中图像的一个单色剪影。

整个绘制过程需要使用到ImageUtil类的createImageByMaskColorEx静态方法,把传入的原图BufferedImage中的指定颜色的背景去掉,返回去掉背景的BufferedImage对象,传送到窗口进行展示。

2.3 游戏对象列表

Java类库中提供了丰富的List接口的实现方法,本项目采用ArrayList存放游戏运行过程中的游戏对象。

滚动背景模块

  1. // 欢迎界面图像列表
  2. private static BufferedImage titleImage;
  3. // 游戏背景对象
  4. public static Scene scene;

各游戏对象

  1. public static MyPlane myplane = null;
  2. Enemy enemy = null;
  3. public static Boss boss = null;
  4. Bomb bomb = null;
  5. Ball ball = null;
  6. Explosion explosion = null;
  7. Blood blood = null;

存储游戏对象的对象列表

  1. public static List<Enemy> enemyList = new ArrayList<Enemy>();
  2. public static List<MyPlane> meList = new ArrayList<MyPlane>();
  3. public static List<Bomb> bombList = new ArrayList<Bomb>();
  4. public static List<Ball> ballList = new ArrayList<Ball>();
  5. public static List<Explosion> explosionList = new ArrayList<Explosion>();
  6. public static List<Blood> bloodList = new ArrayList<Blood>();

游戏运行相关参数

  1. int speed; // 战机的速度,方向键控制
  2. public static int myLife; // 为战机设置生命值
  3. public static int lifeNum; // 战机命条数
  4. public static int myScore; // 战机的得分
  5. public static int passScore; // 当前关卡得分数
  6. public static int lifeCount; // 血包产生控制参数
  7. public static boolean bloodExist; // 标记屏幕中是否存在血包
  8. public static int magicCount; // 魔法值,控制能否发大招
  9. public static int bossBlood; // Boss血量
  10. public static int passNum; // 记录当前关卡

游戏运行相关标志位

  1. public static boolean isPass; // 是否通关的标志
  2. public static boolean isPause; // 是否暂停
  3. public static boolean isBoss; // 标记是否进入Boss
  4. public static boolean bossLoaded; // 标记Boss出场完成
  5. public static boolean isProtect; // 标记是否开启防护罩
  6. public static boolean isUpdate; // 标记战机是否升级
  7. public static boolean test; // 无敌模式参数
  8. public static int isStop; // 标记游戏停止
  9. public static boolean isStarted; // 标记欢迎界面是否加载完成

2.4获取矩形区域

使用 Rectangle的intersects方法来判断两个源矩形是否有重合的部分。如果有重合,返回true,没有从何返回false。

2.5 List<BufferedImage>处理爆炸效果

爆炸效果是连续的显示一系列的图片。如果把每一张图片都在要显示的时候进行加载,占用的时间是非常多的,必然后导致程序的可行性下降。List<BufferedImage>是一个“图象列表”是相同大小图象的集合,每个图象都可由其基于零的索引来参考。可以用来存放爆炸效果的一组图片,通过Timer消息连续循环绘制出List<BufferedImage>中的多张图片做成的爆炸效果。

3 总体设计与详细设计

3.1 系统模块划分

该飞机大战游戏程序分为游戏滚动背景绘制模块、各游戏对象绘制模块、游戏对象之间的碰撞模块、爆炸效果产生模块、游戏界面输出玩家得分关卡信息模块、战机道具技能维护模块、消息处理模块、视图生命周期维护模块。

其中在游戏对象绘制模块中,战机是唯一对象,在游戏开始时产生该对象,赋予其固定的生命值,当其与敌机对象、敌机炸弹碰撞时使其生命值减一,直至生命值为零,便删除战机对象。敌机对象与敌机炸弹对象的绘制中采用定时器技术,定时产生。爆炸对象初始化为空,当游戏过程中即时发生碰撞时,在碰撞位置产生爆炸对象,添加到爆炸链表中,并根据爆炸素材图像分八帧进行输出,达到动画特效。

3.2 主要功能模块

3.2.1 系统对象类图

GameObject是各个游戏对象的抽象父类,继承自Object类,其他的类:战机类、敌机类、爆炸类、子弹类、炸弹类、血包类、文字类都继承了此类,Boss类继承敌机类。
每个游戏对象类中既继承了来自父类GameObject的属性,又有自己的特有属性和方法。

GameObject类介绍:

  1. // 该游戏对象在窗口中的坐标位置
  2. protected Point point;
  3. // 在窗口中绘制该游戏对象图标
  4. public boolean draw(Graphics g, JPanel panel, boolean pause);
  5. // 获取该游戏对象图标在窗口中的矩形框,进行碰撞检测时使用
  6. public Rectangle getRect();
  7. // 加载该游戏对象对应的图像到内存,方便之后的显示调用
  8. public static boolean loadImage(BufferedImage image, String source);

继承GameObject的其他游戏对象类也都重载了相关方法,以便于各个游戏对象在程序的调用过程中调用方式的一致性。

3.2.2 项目包和类层次结构图

  • MyPanel:JPanel的继承类,是飞机大战窗口的总显示面板,其中包含了游戏运行过程中的大量全局参数和全局标记位

  • SpaceWar:程序的入口,窗口对象启动的位置,并在此对相关事件进行了监听

  • Ball:敌机炮弹类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制回想等游戏对象通用操作方法

  • Blood:血包类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制回想等游戏对象通用操作方法

  • Bomb:战机炮弹类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制回想等游戏对象通用操作方法

  • Boss:Boss类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制回想等游戏对象通用操作方法

  • Enemy:敌机类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制回想等游戏对象通用操作方法

  • Explosion:爆炸效果类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制图片等游戏对象通用操作方法

  • GameObject:游戏对象基类,有加载图片,获取矩形框,获取对象位置,绘制图片的游戏对象统一的方法,统一游戏对象的操作方式

  • MyPlane:战机类,继承GameObject,有加载图片,获取矩形框,获取对象位置,绘制图片等游戏对象通用操作方法

  • Scene:场景类,实现了背景滚动,并根据关卡显示不同的背景图片

  • EnemyTask:实现了TimerTask接口,随着Timer计时器的调用而随时间产生敌机对象和敌机炮弹对象,实现自动产生敌机的效果

  • MagicTask:实现了TimerTask接口,随着Timer计时器的调用而随时间改变魔法值

  • RefreshTask:实现了TimerTask接口,随着Timer计时器的调用而随时间刷新窗口界面

  • AudioUtil:音频操作工具类,提供播放背景音乐和操作音效

  • ImageUtil:图片加工工具类,实现了透明贴图方法和背景图片拼接

3.2.3 系统主程序活动图

3.2.4 系统部分流程图

飞机大战游戏执行流程图

定时器产生敌机和炸弹流程图

血包执行流程图

4 编码实现

4.1 滚动背景

在滚动背景的初始化方法和释放方法添加背景音乐播放和释放

  1. //场景类
  2. public class Scene {
  3. private int beginY;// 背景的Y坐标
  4. private List<BufferedImage> images;
  5. public Scene() {
  6. this.images = new ArrayList<BufferedImage>();
  7. }
  8. // 初始化场景
  9. public boolean initScene() {
  10. // 加载开始图片
  11. BufferedImage buffer;
  12. try {
  13. buffer = ImageUtil.copyImage(ImageIO.read(new File(
  14. "images/start.bmp")));
  15. this.images.add(buffer);
  16. // 如果加载失败, 返回false
  17. for (int i = 1; i <= 6; i++) {
  18. buffer = ImageUtil.copyImage(ImageIO.read(new File(
  19. "images/background" + i + ".bmp")));
  20. this.images.add(buffer);
  21. }
  22. } catch (IOException e) {
  23. e.printStackTrace();
  24. return false;
  25. }
  26. // 背景起始坐标为0
  27. this.beginY = 0;
  28. // 播放背景音乐
  29. AudioUtil.playBackground();
  30. return true;
  31. }
  32. // 绘制场景
  33. public void stickScene(Graphics graphics, int index, ImageObserver observer) {
  34. if (index == -1)
  35. index = 0;
  36. else
  37. index = index % 6 + 1;
  38. BufferedImage image = images.get(index);
  39. // 窗口滑在图片中间
  40. if (beginY >= 0
  41. && beginY + SpaceWar.WINDOWS_HEIGHT <= image.getHeight()) {
  42. BufferedImage buffer = image.getSubimage(0, beginY,
  43. image.getWidth(), SpaceWar.WINDOWS_HEIGHT);
  44. graphics.drawImage(buffer, 0, 0, SpaceWar.WINDOWS_WIDTH,
  45. SpaceWar.WINDOWS_HEIGHT, observer);
  46. } else if (beginY < 0) {
  47. // 超出图片上界
  48. BufferedImage imageUp = image.getSubimage(0, image.getHeight()
  49. + beginY, image.getWidth(), -beginY);
  50. graphics.drawImage(imageUp, 0, 0, SpaceWar.WINDOWS_WIDTH, -beginY,
  51. observer);
  52. graphics.drawImage(image, 0, -beginY, SpaceWar.WINDOWS_WIDTH,
  53. SpaceWar.WINDOWS_HEIGHT, observer);
  54. if (-beginY > SpaceWar.WINDOWS_HEIGHT) {
  55. beginY = image.getHeight() + beginY;
  56. }
  57. }
  58. }
  59. // 移动背景
  60. public void moveBg() {
  61. // 移动背景
  62. beginY -= 1;
  63. }
  64. // 释放内存资源
  65. public void releaseScene() {
  66. for (int i = 0; i < 7; i++)
  67. if (images.get(i) != null)
  68. images.get(i).flush();
  69. // 关闭背景音乐
  70. AudioUtil.stopBackground();
  71. }
  72. public int getBeginY() {
  73. return beginY;
  74. }
  75. public void setBeginY(int beginY) {
  76. this.beginY = beginY;
  77. }
  78. }
  79. //在MyPanel中刷新滚动
  80. // 滚动背景
  81. scene.stickScene(g, -1, this);
  82. scene.moveBg();

4.2 显示战机

  1. if (myplane != null)
  2. {
  3. myplane.draw(g, this, isPause, isProtect);
  4. }

4.3 随机产生敌机和敌机炮弹、Boss炮弹

  1. //随机添加敌机,敌机随机发射炸弹,此时敌机速度与数量和关卡有关
  2. // 根据关卡数产生敌机
  3. if (MyPanel.passNum <= 5) {
  4. // 前五关只有一个方向的敌机
  5. Enemy enemy = new Enemy(Enemy.ENEMY_SPEED, 1);// 设置敌机的方向,从上方飞出
  6. enemyList.add(enemy);// 随机产生敌机
  7. if (new Random().nextInt(2) == 0) {// 控制敌机炮弹发出频率
  8. Ball ball = new Ball(
  9. enemy.getPoint().x + Enemy.ENEMY_WIDTH / 2,
  10. enemy.getPoint().y + Enemy.ENEMY_HEIGHT,
  11. enemy.getDirection());
  12. ball.setBallSpeed(enemy.getSpeed()+2);
  13. MyPanel.ballList.add(ball);
  14. // 音效
  15. AudioUtil.play(AudioUtil.AUDIO_BALL);
  16. }
  17. } else if (MyPanel.passNum > 5) {// 第五关之后,两个方向的敌机
  18. Enemy enemy1 = new Enemy(Enemy.ENEMY_SPEED, 1);// 设置敌机的方向,从上方飞出
  19. enemy1.setSpeed(Enemy.ENEMY_SPEED
  20. + (new Random().nextInt(2) + MyPanel.passNum - 1));
  21. enemyList.add(enemy1);
  22. Enemy enemy2 = new Enemy(Enemy.ENEMY_SPEED, -1);// 设置敌机的方向,从下方飞出
  23. enemy2.setSpeed(Enemy.ENEMY_SPEED
  24. + (new Random().nextInt(2) + MyPanel.passNum - 1));
  25. enemyList.add(enemy2);
  26. int rand = new Random().nextInt(3);
  27. if (rand == 0) {// 控制敌机炮弹发出频率
  28. Ball ball = new Ball(enemy1.getPoint().x + Enemy.ENEMY_WIDTH
  29. / 2, enemy1.getPoint().y + Enemy.ENEMY_HEIGHT,
  30. enemy1.getDirection());
  31. ball.setBallSpeed(enemy1.getSpeed()+2);
  32. MyPanel.ballList.add(ball);
  33. // 音效
  34. AudioUtil.play(AudioUtil.AUDIO_BALL);
  35. }
  36. if (rand == 1) {// 控制敌机炮弹发出频率
  37. Ball ball = new Ball(enemy2.getPoint().x + Enemy.ENEMY_WIDTH
  38. / 2, enemy2.getPoint().y, enemy2.getDirection());
  39. ball.setBallSpeed(enemy2.getSpeed()+2);
  40. MyPanel.ballList.add(ball);
  41. // 音效
  42. AudioUtil.play(AudioUtil.AUDIO_BALL);
  43. }
  44. }
  45. if (MyPanel.isBoss) {
  46. // Boss发射子弹
  47. // 敌机炸弹产生定时器触发
  48. // 设置定时器产生敌机炸弹
  49. Ball ball1 = new Ball(MyPanel.boss.getPoint().x + Boss.BOSS_WIDTH
  50. / 2, MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT, 1);
  51. ball1.setBallSpeed(Ball.BALL_SPEED + (MyPanel.passNum - 1) * 2);
  52. MyPanel.ballList.add(ball1);
  53. Ball ball2 = new Ball(MyPanel.boss.getPoint().x + 5,
  54. MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT, 1);
  55. ball2.setBallSpeed(Ball.BALL_SPEED + (MyPanel.passNum - 1) * 2);
  56. MyPanel.ballList.add(ball2);
  57. Ball ball3 = new Ball(MyPanel.boss.getPoint().x + Boss.BOSS_WIDTH
  58. - 5, MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT, 1);
  59. ball3.setBallSpeed(Ball.BALL_SPEED + (MyPanel.passNum - 1) * 2);
  60. MyPanel.ballList.add(ball3);
  61. Ball ball4 = new Ball(MyPanel.boss.getPoint().x + Boss.BOSS_WIDTH
  62. / 2 + 85, MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT, 1);
  63. ball4.setBallSpeed(Ball.BALL_SPEED + (MyPanel.passNum - 1) * 2);
  64. MyPanel.ballList.add(ball4);
  65. Ball ball5 = new Ball(MyPanel.boss.getPoint().x + Boss.BOSS_WIDTH
  66. / 2 - 85, MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT, 1);
  67. ball5.setBallSpeed(Ball.BALL_SPEED + (MyPanel.passNum - 1) * 2);
  68. MyPanel.ballList.add(ball5);
  69. // 音效
  70. AudioUtil.play(AudioUtil.AUDIO_BALL);
  71. }

4.4 显示战机发射子弹

  1. for (int i = 0; i < bombList.size(); i++) {
  2. bomb = bombList.get(i);
  3. if (bomb == null)
  4. continue;
  5. bomb.setCurrentIndex(i);
  6. bomb.isUpdate = isUpdate;
  7. if (!bomb.draw(g, this, isPause))
  8. i--;
  9. }

4.5 碰撞检测,以战机子弹集中敌机为例

  1. if (MyPanel.myplane != null && !MyPanel.isPause) {
  2. // 子弹打中敌机
  3. boolean flag = false;
  4. for (int i = 0; i < MyPanel.bombList.size(); i++) {
  5. Bomb bomb = MyPanel.bombList.get(i);
  6. if (bomb == null)
  7. continue;
  8. Rectangle bombRectangle = bomb.getRect();
  9. for (int j = 0; j < MyPanel.enemyList.size(); j++) {
  10. Enemy enemy = MyPanel.enemyList.get(j);
  11. if (enemy == null)
  12. continue;
  13. Rectangle enemyRectangle = enemy.getRect();
  14. if (enemyRectangle.intersects(bombRectangle)) {
  15. Explosion explosion = new Explosion(
  16. (bomb.getPoint().x + Bomb.BOMB_WIDTH / 2 - Explosion.EXPLOSION_WIDTH / 2),
  17. (bomb.getPoint().y + Bomb.BOMB_HEIGHT / 2 - Explosion.EXPLOSION_WIDTH / 2));
  18. MyPanel.explosionList.add(explosion);
  19. // 音效
  20. AudioUtil.play(AudioUtil.AUDIO_EXPLOSION);
  21. // 爆炸后删除子弹
  22. MyPanel.bombList.remove(i);
  23. i--;
  24. // 敌机生命值减少
  25. enemy.life -= MyPanel.isUpdate ? 2 : 1;
  26. if (enemy.life <= 0) {
  27. // 增加得分
  28. MyPanel.passScore++;
  29. // 删除敌机
  30. MyPanel.enemyList.remove(j);
  31. j--;
  32. }
  33. // 炮弹已删除,直接跳出本循环
  34. flag = true;
  35. break;
  36. }
  37. }
  38. if (flag)
  39. continue;
  40. if (MyPanel.isBoss && bomb != null) {
  41. // 获得战机子弹的矩形区域
  42. Rectangle bombRect = bomb.getRect();
  43. // 获得Boss的矩形区域
  44. Rectangle bossRect = MyPanel.boss.getRect();
  45. // 判断两个矩形区域是否有交接
  46. if (bombRect.intersects(bossRect)) {
  47. // 将爆炸对象添加到爆炸链表中
  48. Explosion explosion = new Explosion(
  49. (bomb.getPoint().x + Bomb.BOMB_WIDTH / 2 - Explosion.EXPLOSION_WIDTH / 2),
  50. (bomb.getPoint().y + Bomb.BOMB_HEIGHT / 2 - Explosion.EXPLOSION_WIDTH / 2));
  51. MyPanel.explosionList.add(explosion);
  52. // 音效
  53. AudioUtil.play(AudioUtil.AUDIO_EXPLOSION);
  54. // 爆炸后删除子弹
  55. MyPanel.bombList.remove(i);
  56. i--;
  57. bomb = null;
  58. // 是Boss,不删除敌机,只扣血
  59. MyPanel.bossBlood -= MyPanel.isUpdate ? 2 : 1;
  60. if (MyPanel.bossBlood <= 0) {
  61. Explosion explosion1 = new Explosion(
  62. MyPanel.boss.getPoint().x,
  63. MyPanel.boss.getPoint().y);
  64. MyPanel.explosionList.add(explosion1);
  65. Explosion explosion2 = new Explosion(
  66. (MyPanel.boss.getPoint().x + Boss.BOSS_WIDTH),
  67. (MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT));
  68. MyPanel.explosionList.add(explosion2);
  69. Explosion explosion3 = new Explosion(
  70. (MyPanel.boss.getPoint().x + Boss.BOSS_WIDTH),
  71. (MyPanel.boss.getPoint().y));
  72. MyPanel.explosionList.add(explosion3);
  73. Explosion explosion4 = new Explosion(
  74. (MyPanel.boss.getPoint().x),
  75. (MyPanel.boss.getPoint().y + Boss.BOSS_HEIGHT));
  76. MyPanel.explosionList.add(explosion4);
  77. Explosion explosion5 = new Explosion(
  78. (MyPanel.boss.getPoint().x
  79. + Boss.BOSS_WIDTH / 2 - Explosion.EXPLOSION_WIDTH / 2),
  80. (MyPanel.boss.getPoint().y
  81. + Boss.BOSS_HEIGHT / 2 - Explosion.EXPLOSION_WIDTH / 2));
  82. explosion5.setBossDie(true);// 标记最后一个炸弹,炸完之后跳入下一关
  83. MyPanel.explosionList.add(explosion5);
  84. MyPanel.boss = null;
  85. // 过关的标志变量
  86. // isPause = TRUE;
  87. // CMyPlane* temp = myplane;
  88. // myplane = new CMyPlane(FALSE);
  89. MyPanel.myplane = null;
  90. MyPanel.isPass = true;
  91. MyPanel.isBoss = false;
  92. }
  93. }
  94. }
  95. }
  96. }

4.6 显示爆炸效果

  1. for (int i = 0; i < explosionList.size(); i++) {
  2. explosion = explosionList.get(i);
  3. if (explosion == null)
  4. continue;
  5. boolean b = explosion.draw(g, this, isPause);
  6. if (!b) {
  7. explosionList.remove(i);
  8. i--;
  9. }
  10. }

4.7 血包功能

游戏三分之一和三分之二进程时刻出现血包

  1. //开启血包
  2. if (MyPanel.myplane != null && MyPanel.myLife > 0 && !MyPanel.isPause) {
  3. // 关卡打了三分之一三分之二处出现血包
  4. if (MyPanel.passScore > (MyPanel.PASS_SCORE + MyPanel.passNum * 5)
  5. * MyPanel.lifeCount / 3) {
  6. // 若屏幕中有未吃掉的血包,这次不产生血包
  7. if (!MyPanel.bloodExist) {
  8. MyPanel.lifeCount++;
  9. // 产生血包
  10. Blood blood = new Blood();
  11. MyPanel.bloodList.add(blood);
  12. MyPanel.bloodExist = true;
  13. bloodTimer = new Timer();
  14. bloodTimer.schedule(new TimerTask() {
  15. @Override
  16. public void run() {
  17. bloodTimer.cancel();
  18. bloodTimer = null;
  19. MyPanel.bloodExist = false;
  20. // 声明血包位置
  21. for (int i = 0; i < MyPanel.bloodList.size(); i++) {
  22. MyPanel.bloodList.remove(i);
  23. i--;
  24. }
  25. }
  26. }, 10000);
  27. } else
  28. MyPanel.lifeCount++;
  29. }
  30. }
  31. //血包定时器,10秒后血包消失
  32. bloodTimer = new Timer();
  33. bloodTimer.schedule(new TimerTask() {
  34. @Override
  35. public void run() {
  36. bloodTimer.cancel();
  37. bloodTimer = null;
  38. MyPanel.bloodExist = false;
  39. // 声明血包位置
  40. for (int i = 0; i < MyPanel.bloodList.size(); i++) {
  41. MyPanel.bloodList.remove(i);
  42. i--;
  43. }
  44. }
  45. }, 10000);
  46. //显示血包
  47. if (myplane != null && !isPause) {
  48. // 检索血包链表,非空时在所在位置显示
  49. int i = 0;
  50. while (i < bloodList.size()) {
  51. blood = bloodList.get(i);
  52. if (blood == null)
  53. continue;
  54. blood.draw(g, this, false);
  55. i++;
  56. }// while
  57. }
  58. //血包碰撞检测
  59. if (MyPanel.myplane != null && !MyPanel.isPause) {
  60. // 吃到血包
  61. // 声明血包位置
  62. for (int i = 0; i < MyPanel.bloodList.size(); i++) {
  63. Blood blood = MyPanel.bloodList.get(i);
  64. // 获得血包矩形
  65. Rectangle bloodbRect = blood.getRect();
  66. // 获得战机矩形
  67. Rectangle planeRect = MyPanel.myplane.getRect();
  68. // 判断两个矩形区域是否有交接
  69. if (bloodbRect.intersects(planeRect)) {// 音效
  70. AudioUtil.play(AudioUtil.AUDIO_BLOOD);
  71. // 加血效果
  72. MyPanel.myLife += 5;
  73. if (MyPanel.myLife > MyPanel.DEFAULT_LIFE)
  74. MyPanel.myLife = MyPanel.DEFAULT_LIFE;
  75. // TODO 声音
  76. // 加血后血包删除
  77. MyPanel.bloodList.remove(i);
  78. i--;
  79. break;
  80. }// if
  81. }// for
  82. }

4.8 通关和死亡消息页面

  1. if (isStop == FLAG_RESTART) {
  2. Font textFont = new Font("宋体", Font.BOLD, 20);
  3. g.setFont(textFont);
  4. // 设置透明背景
  5. // cdc.SetBkMode(TRANSPARENT);
  6. g.setColor(Color.red);
  7. g.drawString("哇,恭喜你已通关!", SpaceWar.WINDOWS_WIDTH / 2 - 100,
  8. SpaceWar.WINDOWS_HEIGHT / 2 - 30);
  9. g.drawString("您的得分为:" + myScore, SpaceWar.WINDOWS_WIDTH / 2 - 100,
  10. SpaceWar.WINDOWS_HEIGHT / 2 - 10);
  11. g.drawString("COME ON !重新开始?Y/N", SpaceWar.WINDOWS_WIDTH / 2 - 100,
  12. SpaceWar.WINDOWS_HEIGHT / 2 + 10);
  13. return;
  14. } else if (isStop == FLAG_STOP) {
  15. Font textFont = new Font("宋体", Font.BOLD, 20);
  16. g.setFont(textFont);
  17. // 设置透明背景
  18. // cdc.SetBkMode(TRANSPARENT);
  19. g.setColor(Color.red);
  20. // 显示最后结果
  21. g.drawString("GAME OVER!", SpaceWar.WINDOWS_WIDTH / 2 - 100,
  22. SpaceWar.WINDOWS_HEIGHT / 2 - 30);
  23. g.drawString("您的得分为:" + myScore, SpaceWar.WINDOWS_WIDTH / 2 - 100,
  24. SpaceWar.WINDOWS_HEIGHT / 2 - 10);
  25. g.drawString("COME ON !重新开始?Y/N", SpaceWar.WINDOWS_WIDTH / 2 - 100,
  26. SpaceWar.WINDOWS_HEIGHT / 2 + 10);
  27. return;
  28. }

4.9 魔法值控制维护

  1. public class MagicTask extends TimerTask {
  2. @Override
  3. public void run() {
  4. if (MyPanel.myplane != null && !MyPanel.isPause && MyPanel.isStarted) {
  5. // 防护罩和战机升级没打开,魔法值递增
  6. if (!MyPanel.isProtect && !MyPanel.isUpdate) {
  7. MyPanel.magicCount++;
  8. if (MyPanel.magicCount > 10)
  9. MyPanel.magicCount = 10;
  10. }
  11. // 判断是否打开防护罩
  12. if (MyPanel.isProtect) {
  13. // 开启防护罩魔法值递减
  14. MyPanel.magicCount--;
  15. if (MyPanel.magicCount <= 0) {
  16. MyPanel.magicCount = 0;
  17. MyPanel.isProtect = false;
  18. }
  19. }
  20. // 判断是否升级战机
  21. if (MyPanel.isUpdate) {
  22. // 战机升级,魔法值递减
  23. MyPanel.magicCount--;
  24. if (MyPanel.magicCount <= 0) {
  25. MyPanel.magicCount = 0;
  26. MyPanel.isUpdate = false;
  27. MyPanel.myplane.isUpdate = MyPanel.isUpdate;
  28. }
  29. }
  30. }
  31. }
  32. }

4.10 得分到达关卡需求,进入Boss

  1. // 进入Boss
  2. int pScore = MyPanel.PASS_SCORE + MyPanel.passNum * 5;
  3. // TODO调试条件
  4. // if (MyPanel.myplane != null && MyPanel.passScore >= 3 &&
  5. // !MyPanel.isPause&&!MyPanel.isBoss)
  6. if (MyPanel.myplane != null && MyPanel.passScore >= pScore
  7. && !MyPanel.isPause && !MyPanel.isBoss) {
  8. // 进入Boss
  9. MyPanel.isBoss = true;
  10. MyPanel.boss = new Boss(1);
  11. MyPanel.boss.setSpeed(Boss.BOSS_SPEED + MyPanel.passNum - 1);
  12. MyPanel.boss.life = Boss.BOSS_LIFE + MyPanel.passNum * 50;// Boss总血量
  13. MyPanel.bossBlood = Boss.BOSS_LIFE + MyPanel.passNum * 50;// 当前Boss血量
  14. // Boss出场,暂停游戏
  15. MyPanel.bossLoaded = false;
  16. // 重新设置Boss的子弹产生频率,增强Boss子弹发射频率
  17. MyPanel.enemyTimer.cancel();
  18. MyPanel.enemyTimer = null;
  19. MyPanel.enemyTimer = new Timer();
  20. MyPanel.enemyTimer.schedule(new EnemyTask(MyPanel.enemyList), 0,
  21. 2000 - MyPanel.passNum * 120);
  22. }
  23. //显示Boss
  24. if (myplane != null && boss != null && !isPause && isBoss) {
  25. boolean status = boss.draw(g, this, passNum, isPause);
  26. if (status)
  27. bossLoaded = true;
  28. }

4.11 检测标记位isPass,判断打赢Boss,进入下一关

  1. if (MyPanel.isPass) {
  2. MyPanel.isPass = false;
  3. if (MyPanel.passNum == 10)// 10关
  4. {
  5. // 重新初始化数据
  6. MyPanel.killTimer();
  7. MyPanel.myplane = new MyPlane(false);
  8. MyPanel.isPause = true;
  9. MyPanel.isStop = MyPanel.FLAG_RESTART;
  10. // 清屏
  11. }// if
  12. else {
  13. MyPanel.killTimer();
  14. MyPanel.isPause = true;
  15. // 保存所需数据
  16. int tScore = MyPanel.myScore + MyPanel.passScore;
  17. int tPassNum = MyPanel.passNum + 1;
  18. boolean tTest = MyPanel.test;
  19. int magic = MyPanel.magicCount;
  20. // 重新开始游戏
  21. MyPanel.Restart();
  22. MyPanel.myplane = new MyPlane(false);
  23. MyPanel.myScore = tScore;
  24. MyPanel.passNum = tPassNum;
  25. MyPanel.magicCount = magic;
  26. MyPanel.test = tTest;
  27. }// else
  28. }// if

4.12 消息监听

4.12.1 按键监听

  1. // 按键监听
  2. frame.addKeyListener(new KeyListener() {
  3. @Override
  4. public void keyTyped(KeyEvent e) {
  5. // TODO Auto-generated method stub
  6. }
  7. @Override
  8. public void keyReleased(KeyEvent e) {
  9. // TODO Auto-generated method stub
  10. }
  11. @Override
  12. public void keyPressed(KeyEvent event) {
  13. if (MyPanel.myplane != null && !MyPanel.isPause) {
  14. switch (event.getKeyCode()) {
  15. case KeyEvent.VK_LEFT:
  16. int x = MyPanel.myplane.getPoint().x
  17. - MyPanel.DEFAULT_SPEED;
  18. if (x < 0)
  19. x = 0;
  20. MyPanel.myplane.setPoint(new Point(x, MyPanel.myplane
  21. .getPoint().y));
  22. break;
  23. case KeyEvent.VK_RIGHT:
  24. int x1 = MyPanel.myplane.getPoint().x
  25. + MyPanel.DEFAULT_SPEED;
  26. if (x1 > SpaceWar.WINDOWS_WIDTH - Bomb.BOMB_WIDTH)
  27. x1 = SpaceWar.WINDOWS_WIDTH - Bomb.BOMB_WIDTH;
  28. MyPanel.myplane.setPoint(new Point(x1, MyPanel.myplane
  29. .getPoint().y));
  30. break;
  31. case KeyEvent.VK_UP:
  32. int y = MyPanel.myplane.getPoint().y
  33. - MyPanel.DEFAULT_SPEED;
  34. if (y < 0)
  35. y = 0;
  36. MyPanel.myplane.setPoint(new Point(MyPanel.myplane
  37. .getPoint().x, y));
  38. break;
  39. case KeyEvent.VK_DOWN:
  40. int y1 = MyPanel.myplane.getPoint().y
  41. + MyPanel.DEFAULT_SPEED;
  42. if (y1 > SpaceWar.WINDOWS_HEIGHT)
  43. y1 = SpaceWar.WINDOWS_HEIGHT;
  44. MyPanel.myplane.setPoint(new Point(MyPanel.myplane
  45. .getPoint().x, y1));
  46. break;
  47. case KeyEvent.VK_SPACE:
  48. Bomb bomb1 = new Bomb(
  49. MyPanel.myplane.getPoint().x + 10,
  50. MyPanel.myplane.getPoint().y, 1,
  51. MyPanel.isUpdate);
  52. MyPanel.bombList.add(bomb1);
  53. Bomb bomb2 = new Bomb(MyPanel.myplane.getPoint().x
  54. + MyPlane.PLANE_WIDTH - 40, MyPanel.myplane
  55. .getPoint().y, 1, MyPanel.isUpdate);
  56. MyPanel.bombList.add(bomb2);
  57. // 音效
  58. AudioUtil.play(AudioUtil.AUDIO_BOMB);
  59. break;
  60. case KeyEvent.VK_C:
  61. // 开启防护罩
  62. MyPanel.isProtect = true;
  63. // 音效
  64. AudioUtil.play(AudioUtil.AUDIO_PROTECT);
  65. break;
  66. case KeyEvent.VK_V:
  67. // 战机升级
  68. MyPanel.isUpdate = true;
  69. MyPanel.myplane.isUpdate = true;
  70. // 音效
  71. AudioUtil.play(AudioUtil.AUDIO_UPDATE);
  72. break;
  73. case KeyEvent.VK_Y:
  74. if (MyPanel.isStop == 0) {
  75. // 无敌模式开关
  76. if (MyPanel.test == false)
  77. MyPanel.test = true;
  78. else
  79. MyPanel.test = false;
  80. }
  81. break;
  82. case KeyEvent.VK_X:// 大招
  83. if (MyPanel.bossLoaded) {
  84. // 战机发大招
  85. if (MyPanel.magicCount >= 10) {
  86. MyPanel.magicCount -= 10;
  87. // 清空敌机
  88. for (int i = 0; i < MyPanel.enemyList.size(); i++) {
  89. Enemy enemy = MyPanel.enemyList.get(i);
  90. // 将爆炸对象添加到爆炸链表中
  91. Explosion explosion = new Explosion(
  92. (enemy.getPoint().x + Enemy.ENEMY_WIDTH / 2),
  93. (enemy.getPoint().y + Enemy.ENEMY_HEIGHT / 2));
  94. MyPanel.explosionList.add(explosion);
  95. // 删除敌机
  96. MyPanel.enemyList.remove(i);
  97. // 增加得分
  98. MyPanel.passScore++;
  99. }// for
  100. if (MyPanel.isBoss) {
  101. // 将爆炸对象添加到爆炸链表中
  102. Explosion explosion = new Explosion(
  103. MyPanel.boss.getPoint().x
  104. + Boss.BOSS_WIDTH / 2,
  105. MyPanel.boss.getPoint().y
  106. + Boss.BOSS_HEIGHT / 2);
  107. MyPanel.explosionList.add(explosion);
  108. MyPanel.bossBlood -= 50;
  109. if (MyPanel.bossBlood <= 0) {
  110. // boss死,过关
  111. // 过关的标志变量
  112. MyPanel.boss = null;
  113. // 过关的标志变量
  114. MyPanel.isPause = true;
  115. MyPanel.myplane = new MyPlane(false);
  116. MyPanel.isPass = true;
  117. MyPanel.isBoss = false;
  118. }
  119. }
  120. // 清空敌机炮弹
  121. for (int i = 0; i < MyPanel.ballList.size(); i++) {
  122. MyPanel.ballList.remove(i);
  123. }
  124. // 音效
  125. AudioUtil.play(AudioUtil.AUDIO_DAZHAO);
  126. }
  127. }
  128. break;
  129. default:
  130. break;
  131. }
  132. }
  133. // 暂停
  134. if (event.getKeyCode() == KeyEvent.VK_Z) {
  135. if (MyPanel.isPause)
  136. MyPanel.isPause = false;
  137. else
  138. MyPanel.isPause = true;
  139. }
  140. // 取消键N
  141. else if (event.getKeyCode() == KeyEvent.VK_N) {
  142. if (MyPanel.isStop != 0) {
  143. JDialog dialog = new JDialog(frame);
  144. dialog.setTitle("关于");
  145. dialog.setSize(400, 200);
  146. dialog.setLocation(450, 200);
  147. JButton button = new JButton();
  148. button.setText("确定");
  149. button.setSize(100, 50);
  150. button.setLocation(200, 120);
  151. button.addActionListener(new ActionListener() {
  152. @Override
  153. public void actionPerformed(ActionEvent e) {
  154. System.exit(0);
  155. }
  156. });
  157. dialog.add(button);
  158. dialog.setVisible(true);
  159. }
  160. }
  161. // 确认键Y
  162. if (MyPanel.isStop != 0
  163. && event.getKeyCode() == KeyEvent.VK_Y) {
  164. MyPanel.isStop = 0;
  165. MyPanel.Restart();
  166. }
  167. // 按空格进入游戏
  168. if (!MyPanel.isStarted
  169. && event.getKeyCode() == KeyEvent.VK_SPACE) {
  170. MyPanel.isStarted = true;
  171. MyPanel.scene.setBeginY(0);
  172. }
  173. }
  174. });

4.12.2 鼠标移动监听

  1. frame.addMouseMotionListener(new MouseMotionListener() {
  2. @Override
  3. public void mouseMoved(MouseEvent arg0) {
  4. if (MyPanel.myplane != null && !MyPanel.isPause)
  5. MyPanel.myplane.setPoint(arg0.getPoint());
  6. }
  7. @Override
  8. public void mouseDragged(MouseEvent arg0) {
  9. }
  10. });

4.12.3 鼠标左键发射子弹和开始界面进入游戏

  1. frame.addMouseListener(new MouseListener() {
  2. @Override
  3. public void mouseReleased(MouseEvent arg0) {
  4. }
  5. @Override
  6. public void mousePressed(MouseEvent event) {
  7. if (MyPanel.myplane != null && !MyPanel.isPause) {
  8. if (event.getButton() == MouseEvent.BUTTON1) {
  9. // 左键
  10. if (MyPanel.myplane != null && !MyPanel.isPause) {
  11. Bomb bomb1 = new Bomb(
  12. MyPanel.myplane.getPoint().x + 10,
  13. MyPanel.myplane.getPoint().y, 1,
  14. MyPanel.isUpdate);
  15. MyPanel.bombList.add(bomb1);
  16. Bomb bomb2 = new Bomb(MyPanel.myplane.getPoint().x
  17. + MyPlane.PLANE_WIDTH - 40, MyPanel.myplane
  18. .getPoint().y, 1, MyPanel.isUpdate);
  19. MyPanel.bombList.add(bomb2);
  20. // 音效
  21. AudioUtil.play(AudioUtil.AUDIO_BOMB);
  22. }
  23. if (!MyPanel.isStarted) {
  24. MyPanel.isStarted = true;
  25. MyPanel.scene.setBeginY(0);
  26. }
  27. }
  28. }
  29. }
  30. @Override
  31. public void mouseExited(MouseEvent arg0) {
  32. }
  33. @Override
  34. public void mouseEntered(MouseEvent arg0) {
  35. }
  36. @Override
  37. public void mouseClicked(MouseEvent arg0) {
  38. }
  39. });

4.13 生命周期

4.13.1游戏重新开始

  1. public static void Restart() {
  2. // TODO: 在此处添加游戏重新开始初始化参数
  3. // 战机重新加载
  4. MyPanel.myplane = new MyPlane(false);
  5. scene.setBeginY(0);
  6. // 清空敌机链表
  7. if (MyPanel.enemyList.size() > 0)
  8. MyPanel.enemyList.removeAll(MyPanel.enemyList);
  9. // 清空战机链表
  10. if (MyPanel.meList.size() > 0)
  11. MyPanel.meList.removeAll(MyPanel.meList);
  12. // 清空战机子弹链表
  13. if (MyPanel.bombList.size() > 0)
  14. MyPanel.bombList.removeAll(MyPanel.bombList);
  15. // 清空敌机炸弹链表
  16. if (MyPanel.ballList.size() > 0)
  17. MyPanel.ballList.removeAll(MyPanel.ballList);
  18. // 清空爆炸链表
  19. if (MyPanel.explosionList.size() > 0)
  20. MyPanel.explosionList.removeAll(MyPanel.explosionList);
  21. // 清空血包列表
  22. if (MyPanel.bloodList.size() > 0)
  23. MyPanel.bloodList.removeAll(MyPanel.bloodList);
  24. // 参数重新初始化
  25. MyPanel.myLife = DEFAULT_LIFE;
  26. MyPanel.lifeNum = DEFAULT_LIFE_COUNT;
  27. MyPanel.myScore = 0;
  28. MyPanel.passScore = 0;
  29. MyPanel.passNum = DEFAULT_PASS;
  30. MyPanel.isPass = false;
  31. MyPanel.isPause = false;
  32. MyPanel.lifeCount = 1;
  33. MyPanel.magicCount = 0;
  34. MyPanel.bloodExist = false;
  35. MyPanel.bossBlood = Boss.BOSS_LIFE;
  36. MyPanel.isBoss = false;
  37. MyPanel.bossLoaded = true;
  38. MyPanel.isProtect = false;
  39. MyPanel.isUpdate = false;
  40. MyPanel.test = false;
  41. MyPanel.boss = null;
  42. // isStarted = FALSE;
  43. initTimer();
  44. }

4.13.2 生命值归零,游戏结束

  1. public static void gameOver() {
  2. // 结束游戏界面
  3. // 释放计时器
  4. killTimer();
  5. // 计算最后得分
  6. myScore += passScore;
  7. // 播放游戏结束音乐
  8. // 清屏
  9. // 音效
  10. AudioUtil.play(AudioUtil.AUDIO_GAMEOVER);
  11. isStop = FLAG_STOP;
  12. // TODO
  13. System.out.println("-----------gameOver");
  14. }

5 课程设计中遇到的主要问题及解决方法

5.1 滚动背景实现问题

要实现滚动背景,需要在背景图上取出客户区矩形大小的区域,并按照Timer进行递进,并且要在背景图边界处衔接好返回背景图开头位置,实现一张背景图的循环反复,达到滚动背景图的目的,刚开始由于不懂得如何实现开头结尾处的衔接问题,导致滚动背景图实现难度大,后来经由网上查阅的资料得知要把背景图加载两份,第二份背景图开头衔接在第一份结尾处,让客户区矩形在该两份背景图上进行滑动,当滑动到第二份背景图时,再把第一份接到第二份结尾处,从而实现循环反复滚动背景。其中实现的难点在于控制好客户区矩形坐标和背景图上要显示的图片块位于图片上的坐标的对应关系。

5.2 背景音乐循环播放和游戏音效同时输出问题

由于平时接触Swing太少,对Swing操作多媒体文件颇为陌生,对于Java的音频播放也是颇为陌生,通过网上查找了很多相关资料,才把AudioClip对音频的播放功能实现,而且刚开始使用,没注意到音频文件播放完的释放问题,导致程序运行一阶段之后出现了内存溢出而崩溃的情况。

5.3 多帧位图素材的动画特效实现问题

飞机大战中的爆炸显示是通过一张带有八个帧的位图进行连续输出实现爆炸特效,刚开始只是简单的在一个while循环中循环八次,结果不尽如人意,后来联想到帧和时间的对应关系,在每一次TimerTask调用时输出一帧,并在爆炸对象中用progress标记位记录播放位置,等到八个帧播放结束时,返回播放结束标记位,在TimerTask中检测并删除播放完成的该爆炸对象。

5.4 游戏结束和游戏重新开始的游戏资源维护问题

该游戏由于实现了多个额外功能,且都是带有全局意义的,因此放置了较多标记位来标记每个状态,通过这些标记位来控制游戏进程中的各个状态,因此在游戏结束和重新开始游戏时,各个标记位的正确重置将会决定重新开始游戏之后的游戏状态。还由于这些操作可能会在TimerTask类调用过程中进行中断,因此程序运行中途的中断时的游戏参数的维护对程序的正确执行至关重要。

6 课程设计体会

由于对Swing接触不多,因此在开发过程中走了很多弯路,但是也是这次的实训,让我了解了Swing的事件处理机制,了解了如何在屏幕中绘制需要向用户展示的图形信息,学会了使用基本的操作对屏幕中绘制的图形进行控制,也了解了Java的Timer定时器的机制,学习了Sun封装好的Swing类库,学会遇到问题到JDK文档中查询Api,并对Eclipse的使用和编程也进行了提高。

在开发过程中遇到了大量的异常,通过此次开发,也学会了遇到错误如何慢慢通过IDE的错误信息进行错误查找和代码排错更正,通过添加断点调试程序一步步监视程序运行的具体过程,从而找到程序运行出错的原因。

本次的课程设计的飞机大战代码是基于前一次的MFC飞机大战进行移植的,因此,在模块的分布和设计方面大多维持原来C++的布局,因此,本次项目开发的源码层次接口没有严格的按照Java的规范,这是这个项目的不足之处,如果时间允许,应该着手对其中的代码布局进行相应的修改,以符合Java的风格,增强代码的可读性。

7 游戏演示

游戏画面1

游戏画面2

上传的附件 cloud_download Java飞机大战游戏设计与实现.7z ( 10.71mb, 552次下载 )
error_outline 下载需要2点积分

发送私信

不想不讲道理但也不要原谅你

3
文章数
4
评论数
最近文章
eject