基于Java实现的潜艇大战游戏

lonelyperson

发布日期: 2019-06-08 13:02:55 浏览量: 423
评分:
star star star star star star star star star_border star_border
*转载请注明来自write-bug.com

一.需求分析

1.1 设计任务

本次游戏课程设计小组成员团队合作的方式,通过游戏总体分析设计,场景画面的绘制,游戏事件的处理,游戏核心算法的分析实现,游戏的碰撞检测,游戏的反复测试,游戏的打包运行等一个完整的游戏设计编码实现的整个过程。进一步提高编写结构清晰,扩展性好,风格良好的应用程序,进一步提高思考解决实际问题的工程能力。

1.2 功能需求

  • 玩家进入游戏,退出游戏的功能,没有过关重玩的功能

  • 玩家开始游戏,暂停游戏,查看游戏规则

  • 玩家键盘A,D(快捷键)鼠标操作实现战舰的移动和投导弹攻击潜艇

  • 潜艇左面出,向右移动,每一个时间间隔向上投鱼雷攻击战舰

  • 战舰和潜艇被攻击后有相应的爆炸特效和对应的音效

  • 玩家的得分统计,进入前十就提示输入姓名,当前最高分的查看

  • 玩家通过的关口统计,下一关口难度增加的设置

1.3 用例模型

  • Actor主要为玩家和游戏系统

  • 玩家 user case 包括 开始游戏,操作战舰,退出游戏,暂停游戏,得分关卡,进入排行榜

  • 游戏系统 user case 潜艇出击,爆炸效果,积分榜重置,结束游戏,场景画面

1.4 性能需求

技术可行性

Windows8.1下的开发平台,Windows 8.1的运行平台,使用Java Swing+AWT图形界面制作客户端程序的技术,界面友好,功能齐全,音效动感,操作简单,的一款潜艇大战游戏.

经济可行性

游戏的关卡设计,使游戏的趣味性高,音效设计,都是基于素材网上的免费资源,单机游戏,开发平台在本地,一台装有JAVA的PC即可提供硬件环境,成本极低。

操作可性性

键盘操作,加快捷键和鼠标结合,提供完整游戏规则,查看即可学习,立刻就可以玩起来,操作非常简单。

1.5 系统结构图

1.6 系统流程图

二.游戏功能内容设计

2.1 工程结构图

2.2 游戏界面绘制

2.2.1 进入游戏界面绘制

首先使用Swing组件的JFrame完成窗口的绘制,包括大小,位置,背景图片,按钮的排放,布局采用BorderLayout的边框布局方式.窗口图标采用Toolkit.getDefaultToolkit().getImage(imgUrl)

2.2.2 游戏主界面的绘制

上面的进入游戏的界面点击进入游戏后切换至主界面里面后,完成主界面的颜色背景绘制,主要使用Graphics2D设置相应的颜色代码完成实现。上面的菜单栏采用JMenuBar,JMenu,JMenuItem来完成绘制。至于得分,关数是在指定的位置绘制的。那个游戏的最高分是从游戏玩家排行榜里面读取出来然后绘制的,命数是自定义的3条。在程序里面设置好的。然后就是战舰和导弹的绘制了的.战舰封装一个战舰对象然后结合Image对象加载图片设置位置来实现的.导弹是初始设置五个,通过线程的方式指定的时间内绘制即可。最多为5个,最小为0个.绘制的时候要注意判断当前的导弹数量来绘制的。

2.2.3 游戏对话框的绘制

实现的方法就是继承JDialog对话框+Graphics2D设置宽高和位置就可以设置的,例如帮助对话框的实现。

  1. private static final long serialVersionUID = 1L;
  2. protected JFrame frame1;
  3. private MyPanel panel;
  4. private boolean flag = false;
  5. private boolean isDraw = false;
  6. private boolean isOutDraw = false;
  7. /** 设置对话框为圆角矩形*/
  8. public void setVisiableRigeon(int width,int height)
  9. {
  10. Shape shape = new RoundRectangle2D.Float(20,20,this.getWidth() - 40,this.getHeight()-40,15.0f,15.0f);
  11. Shape shape2 = new Ellipse2D.Double(this.getWidth() - 40, 10,30,30);
  12. Area area = new Area(shape);
  13. Area area2 = new Area(shape2);
  14. area.add(area2);
  15. AWTUtilities.setWindowShape(this,area);
  16. }

2.3 游戏音效制作

JAVA的AWT下面的AudioClip类播放音乐.wav格式的音乐,音乐文件使用的地方有两个:一个是战舰发射导弹命中潜艇,潜艇发射鱼雷命中战舰的,先展示爆炸图片然后在播放背景音效。

2.4 游戏爆炸场景的设计

类如下

关键方法

  1. private MyPanel panel;
  2. private Image image;
  3. /** 爆炸效果显示的时间默认为700毫秒*/
  4. private int liveTime = 700;
  5. /** 位置 x y*/
  6. private int beginX = 0;
  7. private int beginY= 0;
  8. /** 游戏是否正在运行标志*/
  9. private boolean isRunning = false;
  10. /*绘制爆炸效果图片*/
  11. public void drawHitting(Graphics2D g)
  12. {
  13. g.drawImage(this.image, this.beginX, this.beginY, this.panel);
  14. MusicUtil musicUtil = new MusicUtil();
  15. musicUtil.playMissile();
  16. }
  17. /**圆的半径集合**/
  18. private int[] r = {2,3,5,8,12,15,18,20,25,30,33,25,17,15,13,9,5};
  19. /**集合中圆的位置起始标记**/
  20. private int step = 0;

鱼雷命中潜艇是通过一个动态设置圆半径来实现先从小到大在到小的过程结合音效,效果还是不错的。

2.5 碰撞检测分析实现

碰撞的对象有两对的,分别是潜艇和导弹,鱼雷和战舰。通过位置坐标来判断(核心代码如下)当前战舰的位置坐标和窗体的高度来做一个判断后就取其一半,添加到爆炸绘制数组里面的。绘制的时候都设置和相应的位置坐标的。

  1. /** 判断是否击中战舰 **/
  2. public void hitting()
  3. {
  4. if(this.X > (this.ship.getBeginX() - this.weight) && this.X < (this.ship.getBeginX() + this.ship.getWidth()-this.getWeight()))
  5. {
  6. int num = this.panel.getLiveNum();
  7. blast = new Blast(this.ship.getBeginX() + this.ship.getWidth() /2, this.ship.getBeginY() + this.ship.getHeight() / 2);
  8. Thread t = new Thread(blast);
  9. this.panel.getBlastArray().add(blast);
  10. t.start();
  11. num --;
  12. this.panel.setLiveNum(num);
  13. this.panel.loseGmae();
  14. }
  15. }
  16. /** 根据集合中对象的位置参数判断潜艇和战舰是否被击中*/
  17. public void explode()
  18. {
  19. // this.updateScreen();
  20. if(!this.bumbArray.isEmpty() && !this.submarineArray.isEmpty())
  21. {
  22. for(int i = 0; i < this.bumbArray.size(); i ++)
  23. {
  24. if(((Bumb)this.bumbArray.get(i)).flag == false)
  25. {
  26. for(int j = 0; j < this.submarineArray.size(); j ++)
  27. {
  28. if(((Submarine)this.submarineArray.get(j)).flag == false)
  29. {
  30. int by =((Bumb)this.bumbArray.get(i)).getBeginY();
  31. int syStart = ((Submarine)this.submarineArray.get(j)).getY() - ((Bumb)this.bumbArray.get(i)).getHeight();
  32. int syEnd = ((Submarine)this.submarineArray.get(j)).getY() + ((Submarine)this.submarineArray.get(j)).getHeight();
  33. int bx = ((Bumb)this.bumbArray.get(i)).getBeginX();
  34. int sxStart = ((Submarine)this.submarineArray.get(j)).getX() - ((Bumb)this.bumbArray.get(i)).getWidth();
  35. int sxEnd = ((Submarine)this.submarineArray.get(j)).getX() + ((Submarine)this.submarineArray.get(j)).getWeight();
  36. if( by >= syStart && by <= syEnd && bx >= sxStart && bx <= sxEnd)
  37. {
  38. this.bumbArray.get(i).flag = true;
  39. this.submarineArray.get(j).flag = true;
  40. this.hitX = this.bumbArray.get(i).getBeginX() + 10;
  41. this.hitY = this.bumbArray.get(i).getBeginY() + 30;
  42. //this.hitFlag = true;
  43. Hit hit = new Hit(this.hitX,this.hitY,this);
  44. this.hitArray.add(hit);
  45. Thread t = new Thread(hit);
  46. t.start();
  47. this.score += 10;
  48. this.addPass(this.score);
  49. }
  50. }
  51. }
  52. }
  53. }
  54. }
  55. }

2.6 游戏对象绘制

2.6.1 潜艇对象绘制

通过随机产生随机数,0,1,2分别对应不同的潜艇图片,方向是自左向右的(使用0和1代表)。移动的步长是一个1个单位(初始),还有一个是否运行的标记的,后面线程绘制暂停要使用的。使用Timer计时器来每隔一段时间产生潜艇来不断绘制。

  1. // 计时器方法
  2. public TimeManager(WarShip ship, MyPanel panel)
  3. {
  4. this.ship = ship;
  5. this.panel = panel;
  6. }
  7. @Override
  8. public void run()
  9. {
  10. Random r = new Random();
  11. while(this.panel.isRunning())
  12. {
  13. if(this.panel.isStop() == true)
  14. {
  15. synchronized(MyPanel.subLock)
  16. {
  17. try
  18. {
  19. MyPanel.subLock.wait();
  20. }
  21. catch(Exception e)
  22. {
  23. e.printStackTrace();
  24. //this.flag = true;
  25. this.panel.endGame();
  26. }
  27. }
  28. }
  29. Submarine sm = new Submarine(this.ship,this.panel);
  30. this.panel.getSubmarineArray().add(sm);
  31. Thread t = new Thread(sm);
  32. t.start();
  33. try
  34. {
  35. Thread.sleep(this.speed + r.nextInt(this.speed * 3));
  36. }
  37. catch(Exception e)
  38. {
  39. e.printStackTrace();
  40. }
  41. }
  42. }
  43. // 计时器每隔一段时间产生鱼雷对象
  44. TimeManager2 tm2 = new TimeManager2(this,this.panel,this.ship,this.panel.getTorpedoArray());
  45. Thread t = new Thread(tm2);
  46. t.start();
  47. // 绘制方法
  48. public void drawSubmarine(Graphics2D g)
  49. {
  50. g.drawImage(image,this.X, this.Y, panel);
  51. }

向左向右移动就是增加减少当前的坐标X值.然后重新绘制面板即可判断一下X值的范围。

  1. public void moveLeft()
  2. {
  3. this.X -= dx;
  4. this.panel.repaint();
  5. if(this.X < 0)
  6. {
  7. this.flag = true;
  8. }
  9. }

2.6.2 战舰对象绘制

首先是封装一个战舰对象类。

  1. /** 战舰初始位置和高度,宽度*/
  2. private int beginX ;
  3. private int beginY ;
  4. private int width ;
  5. private int height;
  6. /** 初始炸弹数量*/
  7. private int bombNum = 5;
  8. private MyPanel panel;
  9. /** 图片对象*/
  10. private Image image;

就一句话,使用给出初始时刻的位置坐标X,Y,然后就是加载战舰的图片类,X值为相应窗体宽度的一半,高度就是指定一定的高度。同样也有相应的左移和右移的方法实现,指定每次一定的步长为5个单位。

  1. /** 绘制战舰*/
  2. public void drawShip(Graphics2D g)
  3. { g.drawImage(image,this.beginX ,this.beginY,this.panel);
  4. }
  5. /** 战舰右移动,步长为五*/
  6. public void moveRight()
  7. {
  8. this.beginX +=5;
  9. if((this.beginX + this.width) > this.panel.getWidth())
  10. {
  11. System.out.println("panel:"+this.panel.getWidth());
  12. this.beginX = this.panel.getWidth() - this.width;
  13. }
  14. }
  15. /** 战舰左移动,步长为五*/
  16. public void moveLeft()
  17. {
  18. this.beginX -= 5;
  19. if(this.beginX < 0)
  20. {
  21. this.beginX = 0;
  22. }
  23. }

2.6.3 鱼雷对象绘制

原来和前面相似就不做介绍了的,关键方法如下,移动的距离,鱼雷向上移动。

  1. /** 潜艇对象*/
  2. private WarShip ship;
  3. /** 鱼雷的坐标和宽高*/
  4. private int beginX;
  5. private int beginY;
  6. private int width = 5;
  7. private int height = 15;
  8. public boolean flag = false;
  9. private MyPanel panel;
  10. private Image image;
  11. public Bumb(MyPanel p, WarShip ship)
  12. {
  13. this.beginX= ship.getBeginX()+20;
  14. this.beginY = ship.getBeginY()+20;
  15. this.panel = p;
  16. this.ship = ship;
  17. URL imgUrl=this.getClass().getResource("/images/炸弹.png");
  18. image = Toolkit.getDefaultToolkit().getImage(imgUrl);
  19. image = new ImageIcon(image).getImage();
  20. this.width = image.getWidth(panel);
  21. this.height = image.getHeight(panel);
  22. }
  23. /** 绘制鱼雷*/
  24. public void drawBumb(Graphics2D g)
  25. {
  26. g.drawImage(image, this.beginX, this.beginY, this.panel);
  27. }
  28. /** 鱼雷向下移动*/
  29. public void moveDown()
  30. {
  31. this.beginY += 1;
  32. if(this.beginY > (this.panel.getHeight() - this.height2))
  33. {
  34. flag = true;
  35. }
  36. // this.panel.repaint();
  37. }
  38. // 鱼雷向上移动
  39. public void upMove()
  40. {
  41. this.Y -= this.dy;
  42. if(this.Y <= 150)
  43. {
  44. this.hitting();
  45. this.flag = true;
  46. }
  47. if(this.sm.flag == true)
  48. {
  49. if(this.Y < 150)
  50. {
  51. this.flag = true;
  52. }
  53. }
  54. }

2.6.4 炸弹对象绘制

  1. /** 绘制炸弹*/
  2. public void drawBombNum(Graphics2D g)
  3. {
  4. for(int i = 0;i < this.ship.getBombNum();i ++)
  5. {
  6. g.drawImage(this.bumbImage,this.getWidth()/4 + 25*i + 70, 0,this);
  7. }
  8. }

2.7 战舰装弹实现

  1. /** 装弹保持炸弹数量大于零小于五 并每隔一定时间装弹*/
  2. public void addBomb() {
  3. int bn = this.ship.getBombNum();
  4. if(bn >= 0 && bn < 5)
  5. {
  6. bn ++;
  7. this.ship.setBombNum(bn);
  8. }
  9. if(bn < 0)
  10. {
  11. bn =0;
  12. this.ship.setBombNum(bn);
  13. }
  14. if(bn >= 5)
  15. {
  16. bn = 5;
  17. this.ship.setBombNum(bn);
  18. }
  19. }

2.8 面板绘制

主面板里面绘制的对象非常多连接游戏各个组件的枢纽。

  1. /** 战舰*/
  2. private WarShip ship;
  3. /** 命数默认为3*/
  4. private int liveNum= 3;
  5. /** 通关数默认为0*/
  6. private int pass= 0;
  7. /** 最高分默认为0*/
  8. private int higncore = 0;
  9. /** 玩家得分 默认为0*/
  10. private int score = 0;
  11. /** 战舰装弹速度,默认为3000毫秒*/
  12. private int delay = 3000;
  13. /** 暂停标记*/
  14. private boolean suspendFlag = false;
  15. /** 判断游戏是否正在运行标记*/
  16. private boolean isRunning = false;
  17. /** 潜艇是否被击中标记*/
  18. private boolean hitFlag = false;
  19. /** 击中位置潜艇x坐标*/
  20. private int hitX = 0;
  21. /** 击中位置潜艇y坐标*/
  22. private int hitY = 0;
  23. /** 炸弹图片*/
  24. private Image bumbImage;
  25. /** 击中潜艇效果图片*/
  26. private Image hitImage;
  27. /** 暂停游戏所有线程用到的*/
  28. public static final Object subLock = new Object();
  29. /** 用来不停绘制玩家剩余可用炸弹的计时器*/
  30. private Timer timer;
  31. /** 用来不停重绘面板和判断移动元素位置的计时器*/
  32. private Timer timer3;
  33. /** 用来管理产生潜艇对象的线程*/
  34. private TimeManager tm = null;
  35. /** 炸弹对象集合*/
  36. private ArrayList<Bumb> bumbArray = new ArrayList<Bumb>();
  37. /** 潜水艇对象集合*/
  38. private ArrayList<Submarine> submarineArray = new ArrayList<Submarine>();
  39. /** 鱼雷对象集合*/
  40. private ArrayList<Torpedo> torpedoArray = new ArrayList<Torpedo>();
  41. /** 潜艇爆炸对象集合*/
  42. private ArrayList<Hit> hitArray = new ArrayList<Hit>();
  43. /** 战舰爆炸对象集合*/
  44. private ArrayList<Blast> blastArray = new ArrayList<Blast>();

三.游戏场景创意相关设计

3.1 游戏关卡分数设计

具有挑战创意的分数关卡等你来战,每次多通过一关后,潜艇的速度会变快,就是绘制潜艇的速度会提高的,同时计时器的间隔会减低的。

  1. /** 判断通关数量*/
  2. public void addPass(int score)
  3. {
  4. if(score < 100)
  5. {
  6. this.pass = 0;
  7. }
  8. else if(score >= 100 && score < 200)
  9. {
  10. this.pass = 1;
  11. this.tm.setSpeed(800);
  12. timer.setDelay(2800);
  13. }
  14. else if(score >= 200 && score < 300)
  15. {
  16. this.pass = 2;
  17. this.tm.setSpeed(600);
  18. timer.setDelay(2500);
  19. }
  20. else if(score >= 300 && score < 500)
  21. {
  22. this.pass = 3;
  23. this.tm.setSpeed(500);
  24. timer.setDelay(2300);
  25. }
  26. else if(score >= 500 && score < 800)
  27. {
  28. this.pass = 4;
  29. this.tm.setSpeed(400);
  30. timer.setDelay(2000);
  31. }
  32. else if(score >= 800 && score < 1000)
  33. {
  34. this.pass = 5;
  35. this.tm.setSpeed(300);
  36. timer.setDelay(1800);
  37. }
  38. else if(score >= 1000 && score < 1500)
  39. {
  40. this.pass = 6;
  41. this.tm.setSpeed(200);
  42. timer.setDelay(1500);
  43. }
  44. else if(score >= 1500 && score < 2000)
  45. {
  46. this.pass = 7;
  47. this.tm.setSpeed(100);
  48. timer.setDelay(1200);
  49. }
  50. else if(score >= 2000)
  51. {
  52. this.pass = 8;
  53. this.tm.setSpeed(50);
  54. timer.setDelay(1000);
  55. }
  56. }

还算不错的完成了功能.

3.2 读取游戏最高分

设计通过后判断是否进入前十了的。

  1. /** 得到玩家的最高分*/
  2. public int getHigeScore(InputStream inputStream)
  3. {
  4. BufferedReader bf = null;
  5. int tempNum = 0;
  6. try
  7. {
  8. bf = new BufferedReader(new InputStreamReader(inputStream));
  9. String temp = null;
  10. while((temp = bf.readLine()) != null)
  11. {
  12. String[] info = temp.split(" ");
  13. int num = Integer.valueOf(info[1]);
  14. if(num > tempNum)
  15. {
  16. tempNum = num;
  17. }
  18. }
  19. bf.close();
  20. }
  21. catch(IOException e)
  22. {
  23. e.printStackTrace();
  24. }
  25. finally
  26. {
  27. if(bf != null)
  28. {
  29. try
  30. {
  31. bf.close();
  32. }
  33. catch(IOException e)
  34. {
  35. e.printStackTrace();
  36. }
  37. }
  38. }
  39. return tempNum;
  40. }

游戏界面绘制时要读取出当前的最高分数的,从玩家的排行榜里面读取出来的userInfo/user.txt文件读取。

  1. 计算机网络 630 4 2018-06-09
  2. 归来 570 3 2018-06-08
  3. 时间刺客 480 2 2018-06-07
  4. 图像处理 410 2 2018-06-05
  5. 深入浅出 390 3 2018-06-04
  6. 游戏设计 330 2 2018-06-03
  7. 数据挖掘 270 2 2018-06-03
  8. 多媒体技术 260 2 2018-06-07
  9. 数据结构 250 2 2018-06-10
  10. 集合对象 190 1 2018-06-09

下面是一些关键的代码.按照分数的降序来完成的。

  1. {
  2. // 得到用户信息
  3. String name = InputDialog.this.field.getText().trim();
  4. String score = Integer.toString(InputDialog.this.panel.getScore());
  5. String pass = Integer.toString(InputDialog.this.panel.getPass());
  6. SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  7. String date = df.format(new Date());
  8. String args[] = date.split(" ");
  9. String time = args[0];
  10. String user = name + " " + score + " " + pass + " " + time;
  11. //将数据文件中的用户信息取出,去掉最后一名,加入玩家信息,并按降序排序
  12. ArrayList<String> userList = new ArrayList<String>();
  13. BufferedReader br = null;
  14. BufferedWriter bw = null;

游戏结束执行isRecord方法来判断玩家是否进入前十来实现荣誉榜。

  1. /** 判断玩家成绩是否进入前十名,是的话返回true*/
  2. public boolean isRecord()
  3. {
  4. boolean isRecord = false;
  5. InputStream inputStream=MyPanel.class.getClassLoader().getResourceAsStream("userInfo/user.txt");
  6. BufferedReader bf = null;
  7. int num = 0;
  8. String temp = null;

四.游戏相关测试

4.1 功能测试

4.1.1 游戏测试

测试游戏结束中玩家3条命结束后游戏是否按照预期的就结束了的。正确的应该是弹出一个对话框提示重玩还是退出.错误的就是各种报错了的可以在控制台查看的。

这个测试的过程也同时测试了潜艇的正确运行,战舰的键盘事件,投弹爆炸,音效的测试.和一些功能按钮的测试的.

4.1.2 暂停游戏的测试

鼠标左键实现暂停游戏的功能正确的弹出串口的,查看控制台看是否报错的。

4.2 性能测试

4.2.1 测试战舰装弹的性能来实现

正确进入断点处执行,单步调试

4.2.2 测试战舰键盘事件是否向右移动正确

Debug运行单步调试

五.软件的运行的方式

直接运行

基于jar包的运行,我们使用项目构建工具Maven来快速打成jar包。

进入控制台

使用exe4J将jar打成了可执行文件.exe格式的

点击直接可以运行的。

上传的附件 cloud_download 基于Java实现的潜艇大战游戏.7z ( 1.72mb, 6次下载 )
error_outline 下载需要15点积分

发送私信

曾经输掉的东西,只要你想,就一定可以再一点一点赢回来

15
文章数
24
评论数
最近文章
eject