Code666 (代码贴、代码片段)

[Java] 坦克 →→→→→进入此内容的聊天室

来自 , 2020-12-13, 写在 Java, 查看 100 次.
URL http://www.code666.cn/view/757f843a
  1. package tankwar;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Font;
  5. import java.awt.Graphics;
  6. import java.awt.event.KeyEvent;
  7. import java.awt.event.KeyListener;
  8. import java.io.File;
  9. import java.io.FileInputStream;
  10. import java.util.ArrayList;
  11. import java.util.Random;
  12.  
  13. import javax.swing.BorderFactory;
  14. import javax.swing.ImageIcon;
  15. import javax.swing.JFrame;
  16. import javax.swing.JPanel;
  17.  
  18. import tankwar.Tank.Direction;
  19. import barrier.EnemyBorn;
  20. import barrier.Gold;
  21. import barrier.Home;
  22. import barrier.Iron;
  23. import barrier.SelfBorn;
  24. import barrier.Wall;
  25. /**
  26.  * Java学习交流QQ群：589809992 我们一起学Java！
  27.  */
  28. public class TankWar implements KeyListener {
  29.   static boolean TIMEOUT = false;
  30.   private JFrame f;
  31.   private JPanel gamePanel;
  32.   private PanelShow messgePanel;
  33.   private myPanel p;
  34.   private Tank myTank;
  35.   public static final int AREA_WIDTH = 830;
  36.   public static final int AREA_HEIGHT = 800;
  37.   private ArrayList<Missle> missles = new ArrayList<Missle>();
  38.   private ArrayList<Tank> allTanks = new ArrayList<Tank>();
  39.   private ArrayList<Boom> booms = new ArrayList<Boom>();
  40.   private ArrayList<Wall> walls = new ArrayList<Wall>();
  41.   private ArrayList<Iron> irons = new ArrayList<Iron>();
  42.   private ArrayList<Gold> golds = new ArrayList<Gold>();
  43.   private ArrayList<Item> items = new ArrayList<Item>();
  44.   private ArrayList<EnemyBorn> enemyBorns = new ArrayList<EnemyBorn>();
  45.   private SelfBorn selfBorn;
  46.   private Home home;
  47.   private Tank enemyTank;
  48.   private Random r;
  49.   private ImageIcon backGround;
  50.   private final String map;
  51.   private int tankMax;
  52.   private boolean over = false;
  53.   private static int selfMax = 3;
  54.   private boolean win;
  55.   private boolean flash = false;
  56.   private TankWar tw = this;
  57.   static int SCORE = 0;
  58.  
  59.   private final JFrame mainF;
  60.   private int style;
  61.  
  62.   public TankWar(String map, int tankMax, JFrame mainF, int style)
  63.       throws Exception {
  64.     this.map = map;
  65.     this.tankMax = tankMax;
  66.     this.mainF = mainF;
  67.     this.style = style;
  68.     init();
  69.   }
  70.  
  71.   private void init() {
  72.     f = new JFrame("坦克大战 V3.0");
  73.     gamePanel = new JPanel(null);
  74.     p = new myPanel();
  75.     p.setBackground(Color.WHITE);
  76.     r = new Random();
  77.     messgePanel = new PanelShow();
  78.     initMap(new File("map/" + map));
  79.  
  80.     try {
  81.       myTank = new Tank(selfBorn.getX(), selfBorn.getY(), true, allTanks,
  82.           walls, irons, golds, missles, home, booms, style);
  83.     } catch (Exception e1) {
  84.     }
  85.     myTank.setDir(Direction.U);
  86.  
  87.     allTanks.add(myTank);
  88.     addTank();
  89.     try {
  90.       backGround = new ImageIcon(
  91.           TankWar.class.getResource("/pic/whiteback.jpg"));
  92.     } catch (Exception e) {
  93.     }
  94.  
  95.     p.setBorder(BorderFactory.createEtchedBorder(Color.BLACK, Color.WHITE));
  96.     p.setSize(AREA_WIDTH, AREA_HEIGHT);
  97.     messgePanel.setBounds(AREA_WIDTH, 0, 200, AREA_HEIGHT);
  98.     gamePanel.add(messgePanel);
  99.     gamePanel.add(p);
  100.     f.add(gamePanel);
  101.     f.setBounds(0, 0, AREA_WIDTH + 200, AREA_HEIGHT);
  102.     f.setDefaultCloseOperation(3);
  103.     f.setResizable(true);
  104.     f.setFocusable(true);
  105.     f.addKeyListener(this);
  106.     f.setVisible(true);
  107.  
  108.     new Thread(new Runnable() {
  109.       public void run() {
  110.         while (!over) {
  111.           if (!myTank.isLive()) {
  112.             selfMax--;
  113.             if (selfMax < 0) {
  114.               f.removeKeyListener(tw);
  115.               over = true;
  116.               win = false;
  117.               break;
  118.             } else {
  119.               myTank.setLevel(1);
  120.               myTank.setX(selfBorn.getX());
  121.               myTank.setY(selfBorn.getY());
  122.               myTank.setDir(Direction.U);
  123.               myTank.setHp(50);
  124.               myTank.setLive(true);
  125.             }
  126.           }
  127.           if (tankMax <= 0 && allTanks.size() == 1) {
  128.             f.removeKeyListener(tw);
  129.             over = true;
  130.             win = true;
  131.           }
  132.           if (!home.isLive()) {
  133.             f.removeKeyListener(tw);
  134.             over = true;
  135.             win = false;
  136.           }
  137.           p.repaint();
  138.           myTank.move();
  139.           for (int i = 1; i < allTanks.size(); i++) {
  140.             allTanks.get(i).move();
  141.             allTanks.get(i).setNoFire(myTank.getNoFire() + 1);
  142.             // if(allTanks.get(i).getX()%5==0&&allTanks.get(i).getY()%5==0)
  143.             aI(allTanks.get(i));
  144.           }
  145.           if (allTanks.size() <= enemyBorns.size() + 1)
  146.             addTank();
  147.           myTank.setNoFire(myTank.getNoFire() + 1);
  148.           messgePanel.setEnemyCount(tankMax);
  149.           messgePanel.setSelfCount(selfMax);
  150.           messgePanel.setScore(SCORE);
  151.           if (SCORE % 500 == 0) {
  152.             SCORE += 100;
  153.             Item item = new Item(allTanks, booms, irons, home);
  154.             items.add(item);
  155.             item.start();
  156.           }
  157.           try {
  158.             Thread.sleep(30);
  159.           } catch (InterruptedException e) {
  160.           }
  161.         }
  162.  
  163.         over();
  164.       }
  165.  
  166.     }).start();
  167.  
  168.   }
  169.  
  170.   private class myPanel extends JPanel {
  171.     /**
  172.      *
  173.      */
  174.     private static final long serialVersionUID = 4408440723797225328L;
  175.  
  176.     @Override
  177.     public void paintComponent(Graphics g) {
  178.       super.paintComponent(g);
  179.       g.drawImage(backGround.getImage(), 0, 0, null);
  180.       for (int j = 0; j < walls.size(); j++) {
  181.         walls.get(j).draw(g);
  182.       }
  183.       for (int j = 0; j < irons.size(); j++) {
  184.         irons.get(j).draw(g);
  185.       }
  186.       for (int j = 0; j < golds.size(); j++) {
  187.         golds.get(j).draw(g);
  188.       }
  189.       for (int j = 0; j < enemyBorns.size(); j++) {
  190.         enemyBorns.get(j).draw(g);
  191.       }
  192.       home.draw(g);
  193.       selfBorn.draw(g);
  194.  
  195.       for (int j = 0; j < allTanks.size(); j++) {
  196.         allTanks.get(j).drawTank(g);
  197.       }
  198.       for (int j = 0; j < irons.size(); j++) {
  199.         irons.get(j).draw(g);
  200.       }
  201.  
  202.       for (int i = 0; i < missles.size(); i++) {
  203.         missles.get(i).drawMissle(g);
  204.         if (!missles.get(i).isLive())
  205.           missles.remove(i);
  206.       }
  207.       for (int i = 0; i < booms.size(); i++) {
  208.         if (booms.get(i).isLive())
  209.           booms.get(i).drawBoom(g);
  210.         else
  211.           booms.remove(i);
  212.       }
  213.       for (int j = 0; j < items.size(); j++) {
  214.         if (!items.get(j).isLive()) {
  215.           items.remove(j);
  216.           continue;
  217.         }
  218.         items.get(j).draw(g);
  219.       }
  220.       if (over)
  221.         drawOver(g);
  222.       messgePanel.repaint();
  223.     }
  224.   }
  225.  
  226.   @Override
  227.   public void keyTyped(KeyEvent e) {
  228.     // TODO Auto-generated method stub
  229.  
  230.   }
  231.  
  232.   @Override
  233.   public void keyPressed(KeyEvent e) {
  234.     if (over) {
  235.       if (e.getKeyCode() == KeyEvent.VK_F1) {
  236.         over = false;
  237.         missles.clear();
  238.         allTanks.clear();
  239.         booms.clear();
  240.         walls.clear();
  241.         irons.clear();
  242.         golds.clear();
  243.         enemyBorns.clear();
  244.         try {
  245.           init();
  246.         } catch (Exception e1) {
  247.         }
  248.       } else {
  249.         f.setVisible(false);
  250.         mainF.setSize(800, 800);
  251.         mainF.setVisible(true);
  252.       }
  253.     } else if (e.getKeyCode() == KeyEvent.VK_SPACE) {
  254.       myTank.fire();
  255.     } else {
  256.       myTank.keyPress(e);
  257.     }
  258.   }
  259.  
  260.   @Override
  261.   public void keyReleased(KeyEvent e) {
  262.  
  263.     myTank.keyReleased(e);
  264.   }
  265.  
  266.   public void aI(Tank tank) {
  267.     if (TIMEOUT) {
  268.       tank.setUp(false);
  269.       tank.setLeft(false);
  270.       tank.setDown(false);
  271.       tank.setRight(false);
  272.       return;
  273.     }
  274.  
  275.     if (r.nextInt(40) == 0)
  276.       tank.fire();
  277.     if (r.nextInt(10) == 0) {
  278.       if (tank.getX() >= myTank.getX()
  279.           && tank.getX() <= myTank.getX() + Tank.SIZE
  280.           && tank.getY() > myTank.getY()) {
  281.         tank.setUp(true);
  282.         tank.setLeft(false);
  283.         tank.setDown(false);
  284.         tank.setRight(false);
  285.         tank.setDir(Direction.U);
  286.         return;
  287.       } else if (tank.getX() >= myTank.getX()
  288.           && tank.getX() <= myTank.getX() + Tank.SIZE
  289.           && tank.getY() < myTank.getY()) {
  290.         tank.setUp(false);
  291.         tank.setLeft(false);
  292.         tank.setDown(true);
  293.         tank.setRight(false);
  294.         tank.setDir(Direction.D);
  295.         return;
  296.       }
  297.  
  298.       else if (tank.getX() > myTank.getX()
  299.           && tank.getY() >= myTank.getY()
  300.           && tank.getY() <= myTank.getY() + Tank.SIZE) {
  301.         tank.setUp(false);
  302.         tank.setLeft(true);
  303.         tank.setDown(false);
  304.         tank.setRight(false);
  305.         tank.setDir(Direction.L);
  306.         return;
  307.       } else if (tank.getX() < myTank.getX()
  308.           && tank.getY() >= myTank.getY()
  309.           && tank.getY() <= myTank.getY() + Tank.SIZE) {
  310.         tank.setUp(false);
  311.         tank.setLeft(false);
  312.         tank.setDown(false);
  313.         tank.setRight(true);
  314.         tank.setDir(Direction.R);
  315.         return;
  316.       }
  317.     }
  318.     if (tank.getX() <= 0) {
  319.       tank.setUp(false);
  320.       tank.setLeft(false);
  321.       tank.setDown(false);
  322.       tank.setRight(true);
  323.       tank.setDir(Direction.R);
  324.     }
  325.     if (tank.getY() <= 0) {
  326.       tank.setUp(false);
  327.       tank.setLeft(false);
  328.       tank.setDown(true);
  329.       tank.setRight(false);
  330.       tank.setDir(Direction.D);
  331.     }
  332.     if (tank.getX() >= AREA_WIDTH - Tank.SIZE) {
  333.       tank.setUp(false);
  334.       tank.setLeft(true);
  335.       tank.setDown(false);
  336.       tank.setRight(false);
  337.       tank.setDir(Direction.L);
  338.     }
  339.     if (tank.getY() >= AREA_HEIGHT - Tank.SIZE) {
  340.       tank.setUp(true);
  341.       tank.setLeft(false);
  342.       tank.setDown(false);
  343.       tank.setRight(false);
  344.       tank.setDir(Direction.U);
  345.     } else if (r.nextInt(300) == 1) {
  346.       tank.setUp(true);
  347.       tank.setLeft(false);
  348.       tank.setDown(false);
  349.       tank.setRight(false);
  350.       tank.setDir(Direction.U);
  351.     }
  352.  
  353.     else if (r.nextInt(300) == 2) {
  354.       tank.setUp(false);
  355.       tank.setLeft(true);
  356.       tank.setDown(false);
  357.       tank.setRight(false);
  358.       tank.setDir(Direction.L);
  359.     } else if (r.nextInt(300) == 3) {
  360.       tank.setUp(false);
  361.       tank.setLeft(false);
  362.       tank.setDown(true);
  363.       tank.setRight(false);
  364.       tank.setDir(Direction.D);
  365.     } else if (r.nextInt(300) == 4) {
  366.       tank.setUp(false);
  367.       tank.setLeft(false);
  368.       tank.setDown(false);
  369.       tank.setRight(true);
  370.       tank.setDir(Direction.R);
  371.     }
  372.   }
  373.  
  374.   public void initMap(File file) {
  375.     try {
  376.       FileInputStream read = new FileInputStream(file);
  377.       for (int i = 0; i < AREA_HEIGHT / 50; i++) {
  378.         for (int j = 0; j < AREA_WIDTH / 50; j++) {
  379.           switch (read.read()) {
  380.           case 1:
  381.             walls.add(new Wall(j * 50, i * 50));
  382.             break;
  383.           case 2:
  384.             irons.add(new Iron(j * 50, i * 50));
  385.             break;
  386.           case 3:
  387.             golds.add(new Gold(j * 50, i * 50));
  388.             break;
  389.           case 4:
  390.             selfBorn = new SelfBorn(j * 50, i * 50);
  391.             break;
  392.           case 5:
  393.             enemyBorns.add(new EnemyBorn(j * 50, i * 50));
  394.             break;
  395.           case 6:
  396.             home = new Home(j * 50, i * 50);
  397.             break;
  398.           }
  399.         }
  400.       }
  401.       read.close();
  402.     } catch (Exception e) {
  403.     }
  404.     ;
  405.   }
  406.  
  407.   public void addTank() {
  408.     if (tankMax <= 0)
  409.       return;
  410.     for (int i = allTanks.size(); i < enemyBorns.size() + 1; i++) {
  411.       try {
  412.         int temp = r.nextInt(enemyBorns.size());
  413.         enemyTank = new Tank(enemyBorns.get(temp).getX(), enemyBorns
  414.             .get(temp).getY(), false, allTanks, walls, irons,
  415.             golds, missles, home, booms, r.nextInt(3) + 1);
  416.       } catch (Exception e) {
  417.         e.printStackTrace();
  418.       }
  419.       enemyTank.setDir(Direction.D);
  420.       enemyTank.setDown(true);
  421.       allTanks.add(enemyTank);
  422.       tankMax--;
  423.       if (tankMax <= 0)
  424.         return;
  425.     }
  426.   }
  427.  
  428.   public static void addMyTankLives() {
  429.     selfMax++;
  430.   }
  431.  
  432.   private void over() {
  433.  
  434.     for (int i = 0; i < AREA_HEIGHT / 50; i++) {
  435.       for (int j = 0; j < AREA_WIDTH / 50; j++) {
  436.         irons.add(new Iron(j * 50, i * 50));
  437.         p.repaint();
  438.         try {
  439.           Thread.sleep(5);
  440.         } catch (InterruptedException e) {
  441.         }
  442.       }
  443.     }
  444.     while (true) {
  445.       flash = !flash;
  446.       p.repaint();
  447.       try {
  448.         Thread.sleep(1000);
  449.       } catch (InterruptedException e) {
  450.       }
  451.       f.addKeyListener(this);
  452.     }
  453.   }
  454.  
  455.   private void drawOver(Graphics g) {
  456.     p.repaint();
  457.     g.setColor(Color.red);
  458.     g.setFont(new Font("Arial", 1, 100));
  459.     g.drawString("GAME OVER", 100, 200);
  460.     g.setFont(new Font("Arial", 2, 50));
  461.     if (win)
  462.       g.drawString("Congratulation! You Win!", 100, 400);
  463.     else
  464.       g.drawString("So Sorry, You Lose!", 100, 400);
  465.     if (flash) {
  466.       g.setFont(new Font("Arial", 2, 30));
  467.       g.setColor(Color.BLACK);
  468.       g.drawString("Press F1 to try again...,", 150, 500);
  469.       g.drawString("Press the other Key to Return the Title...,", 150,
  470.           600);
  471.     }
  472.   }
  473. }

回复 "坦克"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666