devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java实现坦克大战_javachengxutankedazhan

作者：Monodyee | 2024-03-27 18:55:37

赞

踩

javachengxutankedazhan

为您提供一个详细并且简单的坦克大战游戏实现的Java代码：

  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import javax.swing.*;
  4.  
  5. public class TankGame extends JFrame {
  6.     public static void main(String[] args) {
  7.         new TankGame().launchFrame();
  8.     }
  9.  
  10.     private void launchFrame() {
  11.         this.setTitle("坦克大战");
  12.         this.setSize(700, 600);
  13.         this.setLocationRelativeTo(null);
  14.         this.setResizable(false);
  15.  
  16.         this.addWindowListener(new WindowAdapter() {
  17.             public void windowClosing(WindowEvent e) {
  18.                 System.exit(0);
  19.             }
  20.         });
  21.  
  22.         this.add(new GamePanel());
  23.  
  24.         this.setVisible(true);
  25.     }
  26. }
  27.  
  28. class GamePanel extends JPanel implements Runnable {
  29.     private static final long serialVersionUID = 1L;
  30.  
  31.     private Tank tank;
  32.     private Bullet bullet;
  33.     private EnemyTank enemyTank;
  34.     private boolean bGameOver = false;
  35.     private boolean bPause = false;
  36.  
  37.     private Image offScreenImage = null;
  38.  
  39.     public GamePanel() {
  40.         this.addKeyListener(new KeyAdapter() {
  41.             public void keyPressed(KeyEvent e) {
  42.                 int code = e.getKeyCode();
  43.  
  44.                 if (code == KeyEvent.VK_Q) {
  45.                     System.exit(0);
  46.                 }
  47.  
  48.                 if (!bGameOver && !bPause) {
  49.                     switch (code) {
  50.                         case KeyEvent.VK_UP:
  51.                             tank.move(Dir.UP);
  52.                             break;
  53.                         case KeyEvent.VK_DOWN:
  54.                             tank.move(Dir.DOWN);
  55.                             break;
  56.                         case KeyEvent.VK_LEFT:
  57.                             tank.move(Dir.LEFT);
  58.                             break;
  59.                         case KeyEvent.VK_RIGHT:
  60.                             tank.move(Dir.RIGHT);
  61.                             break;
  62.                         case KeyEvent.VK_SPACE:
  63.                             bullet = tank.fire();
  64.                             break;
  65.                     }
  66.                 }
  67.             }
  68.  
  69.             public void keyReleased(KeyEvent e) {
  70.                 int code = e.getKeyCode();
  71.  
  72.                 if (!bGameOver && !bPause) {
  73.                     switch (code) {
  74.                         case KeyEvent.VK_UP:
  75.                         case KeyEvent.VK_DOWN:
  76.                         case KeyEvent.VK_LEFT:
  77.                         case KeyEvent.VK_RIGHT:
  78.                             tank.stop();
  79.                             break;
  80.                     }
  81.                 }
  82.             }
  83.         });
  84.  
  85.         this.tank = new Tank(150, 20, Dir.STOP, this);
  86.         this.enemyTank = new EnemyTank(550, 500, Dir.UP, this);
  87.         Thread t = new Thread(this);
  88.         t.start();
  89.     }
  90.  
  91.     public void paint(Graphics g) {
  92.         g.setColor(Color.GREEN);
  93.         g.fillRect(0, 0, 700, 600);
  94.         if (bGameOver) {
  95.             g.setColor(Color.RED);
  96.             g.setFont(new Font("宋体", Font.BOLD, 50));
  97.             g.drawString("游戏结束！", 200, 300);
  98.             return;
  99.         }
  100.  
  101.         if (bPause) {
  102.             g.setColor(Color.RED);
  103.             g.setFont(new Font("宋体", Font.BOLD, 50));
  104.             g.drawString("游戏暂停", 200, 300);
  105.             return;
  106.         }
  107.  
  108.         if (tank.isLive()) {
  109.             tank.draw(g);
  110.         }
  111.  
  112.         if (enemyTank.isLive()) {
  113.             enemyTank.draw(g);
  114.         }
  115.  
  116.         if (bullet != null) {
  117.             bullet.draw(g);
  118.             // 碰撞检测
  119.             if (enemyTank.isLive() && bullet.hit(enemyTank)) {
  120.                 bullet.setLive(false);
  121.                 enemyTank.setLive(false);
  122.                 bGameOver = true;
  123.             }
  124.         }
  125.     }
  126.  
  127.     public void update(Graphics g) {
  128.         if (offScreenImage == null) {
  129.             offScreenImage = this.createImage(700, 600);
  130.         }
  131.  
  132.         Graphics gOffScreen = offScreenImage.getGraphics();
  133.         Color c = gOffScreen.getColor();
  134.         gOffScreen.setColor(Color.GREEN);
  135.         gOffScreen.fillRect(0, 0, 700, 600);
  136.         gOffScreen.setColor(c);
  137.         paint(gOffScreen);
  138.         g.drawImage(offScreenImage, 0, 0, null);
  139.     }
  140.  
  141.     public void run() {
  142.         while (!bGameOver) {
  143.             try {
  144.                 Thread.sleep(50);
  145.             } catch (InterruptedException e) {
  146.                 e.printStackTrace();
  147.             }
  148.  
  149.             if (!bPause && enemyTank.isLive()) {
  150.                 enemyTank.run();
  151.             }
  152.  
  153.             if (bullet != null && bullet.isLive()) {
  154.                 bullet.run();
  155.             }
  156.             this.repaint();
  157.         }
  158.     }
  159.  
  160.     // 暂停游戏
  161.     public void pauseGame() {
  162.         bPause = true;
  163.     }
  164.  
  165.     // 继续游戏
  166.     public void continueGame() {
  167.         bPause = false;
  168.     }
  169.  
  170.     // 重新开始游戏
  171.     public void restartGame() {
  172.         this.tank = new Tank(150, 20, Dir.STOP, this);
  173.         this.enemyTank = new EnemyTank(550, 500, Dir.UP, this);
  174.         this.bullet = null;
  175.         this.bGameOver = false;
  176.     }
  177. }
  178.  
  179. enum Dir {
  180.     UP, DOWN, LEFT, RIGHT, STOP
  181. }
  182.  
  183. class Tank {
  184.     private int x, y;
  185.     private Dir dir;
  186.     private static final int SPEED = 10;
  187.     private boolean live = true;
  188.  
  189.     private GamePanel gamePanel;
  190.  
  191.     public Tank(int x, int y, Dir dir, GamePanel gamePanel) {
  192.         this.x = x;
  193.         this.y = y;
  194.         this.dir = dir;
  195.         this.gamePanel = gamePanel;
  196.     }
  197.  
  198.     public boolean isLive() {
  199.         return live;
  200.     }
  201.  
  202.     public void setLive(boolean live) {
  203.         this.live = live;
  204.     }
  205.  
  206.     public void draw(Graphics g) {
  207.         if (!live) return;
  208.  
  209.         switch (dir) {
  210.             case UP:
  211.                 g.drawImage(Tools.getImage("res/tankU.png"), x, y, null);
  212.                 break;
  213.             case DOWN:
  214.                 g.drawImage(Tools.getImage("res/tankD.png"), x, y, null);
  215.                 break;
  216.             case LEFT:
  217.                 g.drawImage(Tools.getImage("res/tankL.png"), x, y, null);
  218.                 break;
  219.             case RIGHT:
  220.                 g.drawImage(Tools.getImage("res/tankR.png"), x, y, null);
  221.                 break;
  222.         }
  223.     }
  224.  
  225.     public void move(Dir dir) {
  226.         this.dir = dir;
  227.         switch (dir) {
  228.             case UP:
  229.                 y -= SPEED;
  230.                 break;
  231.             case DOWN:
  232.                 y += SPEED;
  233.                 break;
  234.             case LEFT:
  235.                 x -= SPEED;
  236.                 break;
  237.             case RIGHT:
  238.                 x += SPEED;
  239.                 break;
  240.         }
  241.  
  242.         // 边界检测
  243.         if (x < 0) x = 0;
  244.         if (y < 40) y = 40; // 避免将游戏菜单挡住，留一定区域给游戏菜单
  245.         if (x > 630) x = 630;
  246.         if (y > 530) y = 530;
  247.     }
  248.  
  249.     public Bullet fire() {
  250.         int bulletX = x + Tools.getImage("res/tankU.png").getWidth(null) / 2 - Tools.getImage("res/bulletU.gif").getWidth(null) / 2;
  251.         int bulletY = y + Tools.getImage("res/tankU.png").getHeight(null) / 2 - Tools.getImage("res/bulletU.gif").getHeight(null) / 2;
  252.         return new Bullet(bulletX, bulletY, dir, gamePanel);
  253.     }
  254.  
  255.     public void stop() {
  256.         this.dir = Dir.STOP;
  257.     }
  258.  
  259.     // 坦克的碰撞检测
  260.     public Rectangle getRectangle() {
  261.         return new Rectangle(x, y, Tools.getImage("res/tankU.png").getWidth(null), Tools.getImage("res/tankU.png").getHeight(null));
  262.     }
  263. }
  264.  
  265. class EnemyTank extends Tank {
  266.     private static final long serialVersionUID = 1L;
  267.     private int step = 0;
  268.  
  269.     public EnemyTank(int x, int y, Dir dir, GamePanel gamePanel) {
  270.         super(x, y, dir, gamePanel);
  271.     }
  272.  
  273.     @Override
  274.     public void run() {
  275.         // 敌军坦克自动开火
  276.         if (Math.random() > 0.9) {
  277.             this.fire();
  278.         }
  279.  
  280.         // 坦克随机转向和移动，每个方向停留10次才能真正执行移动操作
  281.         if (step == 10) {
  282.             step = 0; // 该步骤结束
  283.             int r = (int) (Math.random() * 4); // 随机生成0到3的整数
  284.             switch (r) {
  285.                 case 0:
  286.                     this.setDir(Dir.UP);
  287.                     break;
  288.                 case 1:
  289.                     this.setDir(Dir.RIGHT);
  290.                     break;
  291.                 case 2:
  292.                     this.setDir(Dir.DOWN);
  293.                     break;
  294.                 case 3:
  295.                     this.setDir(Dir.LEFT);
  296.                     break;
  297.             }
  298.         }
  299.  
  300.         step++;
  301.         move(getDir());
  302.     }
  303. }
  304.  
  305. class Bullet {
  306.     private int x, y;
  307.     private Dir dir;
  308.     private static final int SPEED = 20;
  309.     private boolean live = true;
  310.  
  311.     private GamePanel gamePanel;
  312.  
  313.     public Bullet(int x, int y, Dir dir, GamePanel gamePanel) {
  314.         this.x = x;
  315.         this.y = y;
  316.         this.dir = dir;
  317.         this.gamePanel = gamePanel;
  318.     }
  319.  
  320.     public boolean isLive() {
  321.         return live;
  322.     }
  323.  
  324.     public void setLive(boolean live) {
  325.         this.live = live;
  326.     }
  327.  
  328.     public void draw(Graphics g) {
  329.         if (!live) return;
  330.         switch (dir) {
  331.             case UP:
  332.                 g.drawImage(Tools.getImage("res/bulletU.gif"), x, y, null);
  333.                 break;
  334.             case DOWN:
  335.                 g.drawImage(Tools.getImage("res/bulletD.gif"), x, y, null);
  336.                 break;
  337.             case LEFT:
  338.                 g.drawImage(Tools.getImage("res/bulletL.gif"), x, y, null);
  339.                 break;
  340.             case RIGHT:
  341.                 g.drawImage(Tools.getImage("res/bulletR.gif"), x, y, null);
  342.                 break;
  343.         }
  344.     }
  345.  
  346.     public void run() {
  347.         switch (dir) {
  348.             case UP:
  349.                 y -= SPEED;
  350.                 break;
  351.             case DOWN:
  352.                 y += SPEED;
  353.                 break;
  354.             case LEFT:
  355.                 x -= SPEED;
  356.                 break;
  357.             case RIGHT:
  358.                 x += SPEED;
  359.                 break;
  360.         }
  361.  
  362.         // 边界检测
  363.         if (x < 0 || y < 0 || x > 700 || y > 550) {
  364.             live = false;
  365.             return;
  366.         }
  367.  
  368.         // 子弹与坦克的碰撞检测
  369.         if (gamePanel.tank.isLive() && hit(gamePanel.tank)) {
  370.             live = false;
  371.             gamePanel.tank.setLive(false);
  372.             gamePanel.bGameOver = true;
  373.         }
  374.     }
  375.  
  376.     // 子弹的碰撞检测
  377.     public boolean hit(Tank tank) {
  378.         if (this.isLive() && tank.isLive() && tank.getRectangle().intersects(new Rectangle(x, y, Tools.getImage("res/bulletU.gif").getWidth(null), Tools.getImage("res/bulletU.gif").getHeight(null)))) {
  379.             return true;
  380.         }
  381.         return false;
  382.     }
  383. }
  384.  
  385. class Tools {
  386.     public static Image getImage(String path) {
  387.         return new ImageIcon(path).getImage();
  388.     }
  389. }

以上是一个简单的坦克大战游戏Java实现代码，其中涉及到一些基本的Java语法和图形化界面的实现，您可以自行修改或者扩展它，实现您想要的更多功能。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/326331
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号