基于Java实现的飞机大战小游戏

BaYan01

发布日期: 2021-07-29 10:54:32 浏览量: 293
评分:
star star star star star star star star star star_border
*转载请注明来自write-bug.com

1.实作项目简介

本项目是一款简单的飞机大战小游戏,程序使用Eclipse开发。

2.项目设计

2.1 总体架构设计

2.2 类设计

com.controller包

com.element包

com.manager包

com.show包

2.3 基本功能

  • 玩家飞机有四种不同外型的飞机可选择

  • 通过键盘上下左右键控制飞机的移动

  • 游戏中敌机在界面上方随机出现,自动发射子弹,并且从上到下垂直方向移动,到达边界自动消失

  • Boss飞机在界面上方水平方向随机移动,并且发射子弹的速度大于普通敌机发射子弹的速度

  • 爆炸效果,敌机与Boss机被玩家击中,玩家被敌机子弹击中,玩家与敌机碰撞均有爆炸效果

  • 游戏中的道具有血包和护盾两类,血包可为玩家提供一滴血,护盾可为玩家抵挡3颗子弹,并且只持续5秒钟

  • 玩家的血量上限是10

3.系统实现

3.1 界面

GameHomePanel类

  1. public class GameHomePanel extends JPanel{
  2. private JButton startGameButton = null;
  3. private JButton setPalyerButton = null;
  4. private ImageIcon backImg = null;
  5. public GameHomePanel() {
  6. init();
  7. }
  8. public void init() {
  9. GameLoad.loadImg();
  10. this.startGameButton = new JButton();
  11. this.backImg = GameLoad.imgMap.get("homeimg");
  12. Image img = this.backImg.getImage().getScaledInstance(GameJFrame.GameX,
  13. GameJFrame.GameY, Image.SCALE_SMOOTH);
  14. this.backImg = new ImageIcon(img);
  15. this.startGameButton.setIcon(new ImageIcon("image/startgame.png"));
  16. this.startGameButton.setBounds(GameJFrame.GameX / 10 * 3,
  17. GameJFrame.GameY / 7 * 5, GameJFrame.GameX / 10 * 4, 80);
  18. this.startGameButton.addActionListener(new ActionListener() {
  19. @Override
  20. public void actionPerformed(ActionEvent e) {
  21. // TODO 自动生成的方法存根
  22. GameStart.changePage("game");
  23. }
  24. });
  25. this.startGameButton.setBorderPainted(false);
  26. this.startGameButton.setBackground(new Color(92, 152, 183));
  27. this.startGameButton.setFocusPainted(false);
  28. // this.startGameButton.setContentAreaFilled(false);
  29. this.add(this.startGameButton);
  30. this.setPalyerButton = new JButton("设置");
  31. this.setPalyerButton.setFont(new Font("Courier", Font.BOLD, 26));
  32. this.setPalyerButton.setForeground(new Color(253, 255, 205));
  33. this.setPalyerButton.setBounds(GameJFrame.GameX / 10 * 3 + 50,
  34. GameJFrame.GameY / 7 * 5 + 100, GameJFrame.GameX / 10 * 2, 50);
  35. this.setPalyerButton.addActionListener(new ActionListener() {
  36. @Override
  37. public void actionPerformed(ActionEvent e) {
  38. // TODO 自动生成的方法存根
  39. new GameDialog(GameStart.gj, "Set");
  40. }
  41. });
  42. this.setPalyerButton.setBorderPainted(false);
  43. this.setPalyerButton.setBackground(new Color(92, 152, 183));
  44. this.setPalyerButton.setFocusPainted(false);
  45. this.add(this.setPalyerButton);
  46. this.setLayout(null);
  47. this.setVisible(true);
  48. // System.out.println("home");
  49. }
  50. @Override
  51. public void paint(Graphics g) {
  52. // TODO 自动生成的方法存根
  53. super.paint(g);
  54. g.drawImage(this.backImg.getImage(), 0, 0, null);
  55. g.drawImage(new ImageIcon("image/planemenu.png").getImage(),
  56. 90, 0, null);
  57. }
  58. }

GameJFrame类

  1. public class GameJFrame extends JFrame{
  2. public final static int GameX = 600;
  3. public final static int GameY = 900;
  4. private JPanel jPanel = null; //正在显示的面板
  5. private KeyListener keyListener = null; //键盘监听
  6. private Thread thead = null; //游戏主线程
  7. private JMenuBar menuBar = null; //菜单栏
  8. public GameJFrame() {
  9. init();
  10. }
  11. public void init() {
  12. this.setSize(GameX, GameY); //设置窗体大小
  13. this.setTitle("飞机大战");
  14. this.initJMenuBar();
  15. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  16. this.setLocationRelativeTo(null); //屏幕居中显示
  17. }
  18. protected void initJMenuBar() {
  19. this.menuBar = new JMenuBar();
  20. this.setJMenuBar(this.menuBar);
  21. JMenu menu1 = new JMenu("菜单");
  22. this.menuBar.add(menu1);
  23. JMenuItem item1 = new JMenuItem("开始游戏");
  24. menu1.add(item1);
  25. menu1.addSeparator();
  26. JMenuItem item2 = new JMenuItem("重新开始");
  27. menu1.add(item2);
  28. menu1.addSeparator();
  29. JMenuItem item3 = new JMenuItem("游戏玩法");
  30. menu1.add(item3);
  31. item2.addActionListener(new ActionListener() {
  32. @Override
  33. public void actionPerformed(ActionEvent e) {
  34. if(GameJFrame.this.jPanel instanceof GameMainJPanel)
  35. reStartGame();
  36. }
  37. });
  38. item3.addActionListener(new ActionListener() {
  39. @Override
  40. public void actionPerformed(ActionEvent e) {
  41. // TODO 自动生成的方法存根
  42. new GameDialog(GameJFrame.this, "HowToPlay");
  43. }
  44. });
  45. }
  46. public void changePanel(JPanel jpt) {
  47. if(this.jPanel != null)
  48. this.remove(this.jPanel);
  49. this.jPanel = jpt;
  50. }
  51. /**
  52. * @显示启动界面
  53. */
  54. public void showHomePage() {
  55. if(this.jPanel != null)
  56. this.add(this.jPanel);
  57. if(this.jPanel instanceof Runnable) {
  58. new Thread((Runnable) this.jPanel).start();
  59. }
  60. this.setVisible(true);
  61. }
  62. /**
  63. * 启动方法
  64. */
  65. public void startGame() {
  66. GameThread.reSetAllTime();
  67. if(this.jPanel != null)
  68. this.add(this.jPanel);
  69. if(this.thead == null)
  70. this.thead = new GameThread();
  71. this.thead.start(); //启动游戏主线程
  72. if(this.keyListener == null)
  73. this.keyListener = new GameListener();
  74. this.addKeyListener(this.keyListener);
  75. // this.setVisible(true);
  76. if(this.jPanel instanceof Runnable) {
  77. new Thread((Runnable)this.jPanel).start();
  78. }
  79. System.out.println("startGame: " + Thread.activeCount());
  80. }
  81. public void reStartGame() {
  82. System.out.println("reStartGame: " + Thread.activeCount());
  83. this.EndGame();
  84. this.jPanel = new GameMainJPanel();
  85. // System.out.println("reStart");
  86. // System.out.println(((GameThread)this.thead).isInterrupted());
  87. try {
  88. Thread.sleep(10);
  89. } catch (InterruptedException e) {
  90. e.printStackTrace();
  91. }
  92. this.startGame();
  93. this.reFalsh();
  94. }
  95. public void EndGame() {
  96. //结束run方法,停止相关线程
  97. ((GameMainJPanel)this.jPanel).panelIsRunning = false;
  98. ((GameThread)this.thead).stopGameThread = true;
  99. ((GameThread)this.thead).isRunning = false;
  100. this.remove(this.jPanel);
  101. this.removeKeyListener(this.keyListener);
  102. this.jPanel = null;
  103. this.keyListener = null;
  104. this.thead = null;
  105. }
  106. public void reFalsh() {
  107. this.setVisible(false);
  108. this.setVisible(true);
  109. }
  110. public void addListener() {
  111. if(this.keyListener != null)
  112. this.addKeyListener(this.keyListener);
  113. }
  114. public void removeListener() {
  115. this.removeKeyListener(this.keyListener);
  116. }
  117. public void setjPanel(JPanel jPanel) {
  118. this.jPanel = jPanel;
  119. }
  120. public void setKeyListener(KeyListener keyListener) {
  121. this.keyListener = keyListener;
  122. }
  123. public void setThead(Thread thead) {
  124. this.thead = thead;
  125. }
  126. }

GameMainJPanel类

  1. /**
  2. * @说明 游戏的主要面板
  3. * @功能说明 主要进行元素的显示,同时进行界面的刷新(多线程)
  4. *
  5. * @多线程刷新 1.本类实现线程接口
  6. */
  7. public class GameMainJPanel extends JPanel implements Runnable{
  8. // 联动管理器
  9. private ElementManager em;
  10. public boolean panelIsRunning = true;
  11. public GameMainJPanel() {
  12. init();
  13. }
  14. public void init() {
  15. em = ElementManager.getManager();//得到元素管理器对象
  16. }
  17. @Override
  18. public void paint(Graphics g) {
  19. super.paint(g);
  20. Map<GameElement, List<ElementObj>> all = em.getGameElements();
  21. for(GameElement ge : GameElement.values()) {
  22. List<ElementObj> list = all.get(ge);
  23. for(int i=0; i<list.size(); i++) {
  24. ElementObj obj = list.get(i);
  25. obj.showElement(g);
  26. }
  27. }
  28. g.setFont(new Font("Times New Roman", Font.BOLD, 24));
  29. int allTime = GameThread.getAllTime()/1000;
  30. int munite = allTime / 60;
  31. int second = allTime % 60;
  32. String m;
  33. String s;
  34. if(munite < 10)
  35. m = "0" + Integer.toString(munite);
  36. else
  37. m = Integer.toString(munite);
  38. if(second<10)
  39. s = "0" + Integer.toString(second);
  40. else
  41. s = Integer.toString(second);
  42. g.drawString("Time: "+ m + ":" + s, 0, 50);
  43. }
  44. @Override
  45. public void run() {
  46. while(this.panelIsRunning) {
  47. // System.out.println("多线程运动");
  48. this.repaint();
  49. try {
  50. Thread.sleep(10); //休眠10毫秒 1秒刷新20次
  51. } catch (InterruptedException e) {
  52. e.printStackTrace();
  53. }
  54. }
  55. }
  56. }

3.2 控制

GameListener类

  1. /**
  2. * @说明 监听类,用于监听用户的操作 KeyListener
  3. */
  4. public class GameListener implements KeyListener{
  5. private ElementManager em = ElementManager.getManager();
  6. private Set<Integer> set = new HashSet<Integer>();
  7. @Override
  8. public void keyTyped(KeyEvent e) {
  9. }
  10. @Override
  11. public void keyPressed(KeyEvent e) {
  12. int key = e.getKeyCode();
  13. List<ElementObj> play = em.getElementsByKey(GameElement.PLAY);
  14. for(ElementObj obj : play) {
  15. obj.keyClick(true, e.getKeyCode());
  16. }
  17. }
  18. @Override
  19. public void keyReleased(KeyEvent e) {
  20. List<ElementObj> play = em.getElementsByKey(GameElement.PLAY);
  21. for(ElementObj obj : play) {
  22. obj.keyClick(false, e.getKeyCode());
  23. }
  24. }
  25. }

GameThread类

  1. /**
  2. * @说明 游戏的主线程,用于控制游戏加载,游戏关卡,游戏运行时自动化
  3. * 游戏判定;游戏地图切换 资源释放和重新读取。
  4. */
  5. public class GameThread extends Thread{
  6. private ElementManager em;
  7. public boolean stopGameThread = false;
  8. public boolean isRunning = true;
  9. private static int allTime = 2* 60 * 1000; //2分钟
  10. private static int sleepTime = 10;
  11. private int winNumbers = 70; //赢得游戏需击杀的敌人数
  12. public GameThread() {
  13. em = ElementManager.getManager();
  14. }
  15. @Override
  16. public void run() {//游戏的run方法 ,主线程
  17. while(!this.stopGameThread) {
  18. // 加载游戏资源(场景资源)
  19. gameLoad();
  20. // 游戏进行时游戏过程中
  21. gameRun();
  22. // 游戏场景结束游戏资源回收(场景资源)
  23. gameOver();
  24. try {
  25. sleep(50);
  26. } catch (InterruptedException e) {
  27. e.printStackTrace();
  28. }
  29. }
  30. // System.out.println("游戏主线程中断");
  31. }
  32. /**
  33. * 游戏的加载
  34. */
  35. private void gameLoad() {
  36. System.out.println("加载中。。。。。");
  37. // GameLoad.loadImg(); //加载图片
  38. GameLoad.loadMap(1); //可以变为变量,每一关重新加载 加载地图
  39. // 加载主角
  40. GameLoad.loadPlay(GameDialog.getPlayN());//也可以带参数,单机还是2人
  41. // 加载敌人NPC等
  42. GameLoad.loadEnemy(3);
  43. // 全部加载完成,游戏启动
  44. }
  45. /**
  46. * @说明 游戏进行时
  47. * @任务说明 游戏过程中需要做的事情:1.自动化玩家的移动,碰撞,死亡
  48. * 2.新元素的增加(NPC死亡后出现道具)等
  49. * */
  50. private void gameRun() {
  51. long gameTime = 0L;
  52. // System.out.println(this.getName());
  53. System.out.println("加载成功,进入游戏");
  54. while(this.isRunning) {
  55. Map<GameElement, List<ElementObj>> all = em.getGameElements();
  56. List<ElementObj> enemys = em.getElementsByKey(GameElement.ENEMY);
  57. List<ElementObj> files = em.getElementsByKey(GameElement.PLAYFILE);
  58. List<ElementObj> maps = em.getElementsByKey(GameElement.MAPS);
  59. List<ElementObj> props = em.getElementsByKey(GameElement.PROP);
  60. List<ElementObj> player = em.getElementsByKey(GameElement.PLAY);
  61. List<ElementObj> enemyFiles = em.getElementsByKey(GameElement.ENEMYFILE);
  62. List<ElementObj> boss = em.getElementsByKey(GameElement.BOSS);
  63. List<ElementObj> shield = em.getElementsByKey(GameElement.SHIELD);
  64. moveAndUpdate(all,gameTime); //游戏元素自动化方法
  65. ElementPK(files, enemys, 0);
  66. ElementPK(player, props, 1);
  67. ElementPK(player, enemys, 0);
  68. ElementPK(files, boss, 0);
  69. ElementPK(player, enemyFiles, 0);
  70. ElementPK(files, enemyFiles, 0);
  71. ElementPK(shield, enemyFiles, 0);
  72. ElementPK(enemyFiles, shield, 0);
  73. gameTime++; //唯一的时间控制
  74. if(gameTime % 300 == 0)
  75. GameLoad.loadEnemy(3); //设置敌人数量
  76. if(gameTime % 2000 == 0) { //间隔20秒出现boss
  77. GameLoad.loadBoss(new Random().nextInt(2) + 1, gameTime); //设置boss数量
  78. }
  79. // System.out.println("isRunning");
  80. this.MedJudge();
  81. allTime -= sleepTime;
  82. try {
  83. sleep(10);//默认理解为 1秒刷新100次
  84. } catch (InterruptedException e) {
  85. e.printStackTrace();
  86. }
  87. }
  88. }
  89. private void MedJudge() {
  90. if(em.getElementsByKey(GameElement.PLAY).size() <= 0) {
  91. GameStart.gj.EndGame();
  92. new GameDialog(GameStart.gj, "LoseGame");
  93. return;
  94. }
  95. if(allTime <= 0) {
  96. int n = ((PaoPao)em.getElementsByKey(GameElement.PLAY).get(0)).getKillEnemy();
  97. if(n < winNumbers) {
  98. // System.out.println("失败");
  99. GameStart.gj.EndGame();
  100. new GameDialog(GameStart.gj, "LoseGame");
  101. }else {
  102. GameStart.gj.EndGame();
  103. new GameDialog(GameStart.gj, "WinGame");
  104. }
  105. }
  106. }
  107. /**
  108. * @说明 碰撞处理
  109. * @param listA 如果是单方面损失碰撞,则这个变量不受损失
  110. * @param listB
  111. * @param type 碰撞类型,0表示互损碰撞,1表示单方面损失碰撞
  112. */
  113. public void ElementPK(List<ElementObj> listA, List<ElementObj>listB,
  114. int type) {
  115. for(int i=0; i<listA.size(); i++) {
  116. ElementObj lista = listA.get(i);
  117. for(int j=0; j<listB.size(); j++) {
  118. ElementObj listb = listB.get(j);
  119. if(lista.pk(listb)) {
  120. if(type == 0) {
  121. lista.setLive(false);
  122. listb.setLive(false);
  123. if(lista instanceof Enemy ||
  124. lista instanceof Boss) {
  125. if(!lista.isLive() &&
  126. em.getElementsByKey(GameElement.PLAY).size() > 0)
  127. //如果想做双玩家模式,要区别是哪个击杀的
  128. ((PaoPao)em.getElementsByKey(GameElement.PLAY).get(0)).addKillEnemy(1);
  129. }
  130. if(listb instanceof Enemy ||
  131. listb instanceof Boss) {
  132. if(!listb.isLive() &&
  133. em.getElementsByKey(GameElement.PLAY).size() > 0)
  134. ((PaoPao)em.getElementsByKey(GameElement.PLAY).get(0)).addKillEnemy(1);
  135. }
  136. }
  137. else if(type == 1) {
  138. lista.setLive(true);
  139. listb.setLive(false);
  140. }
  141. break;
  142. }
  143. }
  144. }
  145. }
  146. // 游戏元素自动化方法
  147. public void moveAndUpdate(Map<GameElement, List<ElementObj>> all,long gameTime) {
  148. for(GameElement ge:GameElement.values()) {
  149. List<ElementObj> list = all.get(ge);
  150. for(int i=list.size()-1; i>=0 ;i--){
  151. ElementObj obj=list.get(i);
  152. if(!obj.isLive()) { //如果死亡
  153. obj.die();
  154. list.remove(i);
  155. continue;
  156. }
  157. obj.model(gameTime);
  158. }
  159. }
  160. }
  161. /**游戏结束*/
  162. private void gameOver() {
  163. for(GameElement ge : GameElement.values()) {
  164. if(this.em.getElementsByKey(ge).size() > 0)
  165. this.em.getElementsByKey(ge).clear();
  166. }
  167. System.out.println("gameOver");
  168. }
  169. public static void reSetAllTime() {
  170. allTime = 2 * 60 * 1000;
  171. }
  172. public static int getAllTime() {
  173. return allTime;
  174. }
  175. }

3.3 资源管理

ElementManager类

  1. /**
  2. * @说明 本类是元素管理器,专门存储所有的元素,同时,提供方法
  3. * 给予视图和控制获取数据
  4. */
  5. public class ElementManager {
  6. private Map<GameElement,List<ElementObj>> gameElements;
  7. public Map<GameElement, List<ElementObj>> getGameElements() {
  8. return gameElements;
  9. }
  10. // 添加元素(多半由加载器调用)
  11. public void addElement(ElementObj obj,GameElement ge) {
  12. gameElements.get(ge).add(obj); //添加对象到集合中,按key值就行存储
  13. }
  14. public List<ElementObj> getElementsByKey(GameElement ge){
  15. return gameElements.get(ge);
  16. }
  17. private static ElementManager EM = null; //引用
  18. // synchronized线程锁->保证本方法执行中只有一个线程
  19. public static synchronized ElementManager getManager() {
  20. if(EM == null) { //控制判定
  21. EM = new ElementManager();
  22. }
  23. return EM;
  24. }
  25. private ElementManager() { //私有化构造方法
  26. init(); //实例化方法
  27. }
  28. /**
  29. * 本方法是为 将来可能出现的功能扩展,重写init方法准备的。
  30. */
  31. public void init() { //实例化在这里完成
  32. gameElements = new HashMap<GameElement,List<ElementObj>>();
  33. // 将每种元素集合都放入到 map中
  34. for(GameElement ge : GameElement.values()) { //通过循环读取枚举类型的方式添加集合
  35. gameElements.put(ge, new ArrayList<ElementObj>());
  36. }
  37. }
  38. }

GameLoad类

  1. /**
  2. * 说明 加载器(工具:用户读取配置文件的工具)工具类,大多提供的是 static方法
  3. * @author
  4. *
  5. */
  6. public class GameLoad {
  7. private static ElementManager em = ElementManager.getManager();
  8. public static Map<String,ImageIcon> imgMap = new HashMap<>();
  9. // 用户读取文件的类
  10. private static Properties pro =new Properties();
  11. /**
  12. * @说明 传入地图id有加载方法依据文件规则自动产生地图文件名称,加载文件
  13. * ,如果有地图可调用这个方法
  14. * @param mapId 文件编号,文件id
  15. */
  16. public static void MapLoad(int mapId) {
  17. String mapName = "com/text/" + mapId + ".map";
  18. ClassLoader classLoader = GameLoad.class.getClassLoader();
  19. InputStream maps = classLoader.getResourceAsStream(mapName);
  20. if(maps == null) {
  21. System.out.println("配置文件读取异常,请重新安装");
  22. return;
  23. }
  24. try {
  25. pro.clear();
  26. pro.load(maps);
  27. Enumeration<?> names = pro.propertyNames();
  28. while(names.hasMoreElements()) { //获取是无序的
  29. String key = names.nextElement().toString();
  30. System.out.println(pro.getProperty(key));
  31. String [] arrs = pro.getProperty(key).split(";");
  32. for(int i=0; i<arrs.length; i++) {
  33. ElementObj obj = getObj("map");
  34. ElementObj element = obj.createElement(key+","+arrs[i]);
  35. System.out.println(element);
  36. em.addElement(element, GameElement.MAPS);
  37. }
  38. }
  39. } catch (IOException e) {
  40. e.printStackTrace();
  41. }
  42. }
  43. /**
  44. *@说明 加载图片代码
  45. *
  46. */
  47. public static void loadImg() { //可以带参数,因为不同的关也可能需要不一样的图片资源
  48. String texturl = "com/text/GameData.pro"; //文件的命名可以更加有规律
  49. ClassLoader classLoader = GameLoad.class.getClassLoader();
  50. InputStream texts = classLoader.getResourceAsStream(texturl);
  51. pro.clear();
  52. try {
  53. // System.out.println(texts);
  54. pro.load(texts);
  55. Set<Object> set = pro.keySet();
  56. for(Object o:set) {
  57. String url=pro.getProperty(o.toString());
  58. // System.out.println(o.toString() + url);
  59. imgMap.put(o.toString(), new ImageIcon(url));
  60. }
  61. } catch (IOException e) {
  62. e.printStackTrace();
  63. }
  64. }
  65. /**
  66. * 加载玩家
  67. */
  68. public static void loadPlay(int playN) {
  69. loadObj();
  70. String playStr = "250,800,player" + String.valueOf(playN);
  71. ElementObj obj = getObj("paopao");
  72. ElementObj play = obj.createElement(playStr);
  73. em.addElement(play, GameElement.PLAY);
  74. }
  75. public static void loadEnemy(int enemyNumber) {
  76. loadObj();
  77. // ElementObj obj = getObj("enemy");
  78. for(int i=0; i<enemyNumber; i++) {
  79. ElementObj obj = getObj("enemy");
  80. ElementObj enemy = obj.createElement(null);
  81. em.addElement(enemy, GameElement.ENEMY);
  82. }
  83. }
  84. public static void loadBoss(int bossNumber, long gameTime) {
  85. loadObj();
  86. for(int i=0; i<bossNumber; i++) {
  87. ElementObj obj = getObj("boss");
  88. ElementObj boss = obj.createElement(null);
  89. em.addElement(boss, GameElement.BOSS);
  90. }
  91. }
  92. public static void loadMap(int mapsNumber) {
  93. loadObj();
  94. for(int i=0; i<mapsNumber; i++) {
  95. ElementObj obj = getObj("maps");
  96. ElementObj maps = obj.createElement(null);
  97. em.addElement(maps, GameElement.MAPS);
  98. }
  99. }
  100. public static ElementObj getObj(String str) {
  101. try {
  102. Class<?> class1 = objMap.get(str);
  103. Object newInstance = class1.newInstance();
  104. if(newInstance instanceof ElementObj) {
  105. return (ElementObj)newInstance; //这个对象就和new Play()等价
  106. }
  107. } catch (InstantiationException e) {
  108. e.printStackTrace();
  109. } catch (IllegalAccessException e) {
  110. e.printStackTrace();
  111. }
  112. return null;
  113. }
  114. /**
  115. * 扩展: 使用配置文件,来实例化对象 通过固定的key(字符串来实例化)
  116. * @param args
  117. */
  118. private static Map<String,Class<?>> objMap=new HashMap<>();
  119. public static void loadObj() {
  120. String texturl = "com/text/obj.pro"; //文件的命名可以更加有规律
  121. ClassLoader classLoader = GameLoad.class.getClassLoader();
  122. InputStream texts = classLoader.getResourceAsStream(texturl);
  123. pro.clear();
  124. try {
  125. pro.load(texts);
  126. Set<Object> set = pro.keySet();
  127. for(Object o:set) {
  128. String classUrl=pro.getProperty(o.toString());
  129. // 使用反射的方式直接将类进行获取
  130. Class<?> forName = Class.forName(classUrl);
  131. objMap.put(o.toString(), forName);
  132. }
  133. } catch (IOException e) {
  134. e.printStackTrace();
  135. } catch (ClassNotFoundException e) {
  136. e.printStackTrace();
  137. }
  138. }
  139. // 用于测试
  140. // public static void main(String[] args) {
  141. // MapLoad(5);
  142. //
  143. // }
  144. }

4.游戏界面展示

游戏界面1

游戏界面2

游戏界面3

5.不足

  • 只有一个游戏关卡

  • 游戏平衡欠缺

  • 无背景音乐

上传的附件 cloud_download GameFrame.zip ( 6.38mb, 1次下载 )
error_outline 下载需要11点积分

发送私信

1
文章数
1
评论数
最近文章
eject