Java坦克大战代码

小九九

1. import java.awt.Color;
   
2. import java.awt.Graphics;
   
3. import java.awt.event.KeyAdapter;
   
4. import java.awt.event.KeyEvent;
   
5. import java.util.ArrayList;
   
6. import java.util.Iterator;
   
7. import java.util.List;
   
8. import java.util.Random;
   
9. import javax.swing.JFrame;
   
10. import javax.swing.JPanel;
    
11. 
    
12. public class TankMovementWithKeysAndBullets extends JPanel {
    
13. 
    
14.     private int x = 175;
    
15.     private int y = 340;
    
16.     private static final int TANK_WIDTH = 30;
    
17.     private static final int TANK_HEIGHT = 15;
    
18.     private static final int MOVE_DISTANCE = 5;
    
19. 
    
20.     private static final int CANNON_HEIGHT = 10;
    
21.     private static final int WHEEL_DIAMETER = 10;
    
22. 
    
23.     private List<Bullet> bullets = new ArrayList<>();
    
24.     private List<EnemyTank> enemyTanks = new ArrayList<>();
    
25.     private boolean spacePressed = false;
    
26.     private int cannonDirection = 0; // 0: up, 1: right, 2: down, 3: left
    
27.     private int enemiesDefeated = 0;
    
28. 
    
29.     public TankMovementWithKeysAndBullets() {
    
30.         addKeyListener(new KeyAdapter() {
    
31.             @Override
    
32.             public void keyPressed(KeyEvent e) {
    
33.                 handleKeyPress(e.getKeyCode());
    
34.                 repaint();
    
35.             }
    
36. 
    
37.             @Override
    
38.             public void keyReleased(KeyEvent e) {
    
39.                 if (e.getKeyCode() == KeyEvent.VK_SPACE) {
    
40.                     spacePressed = false;
    
41.                 }
    
42.             }
    
43.         });
    
44.         setFocusable(true);
    
45. 
    
46.         new Thread(() -> {
    
47.             Random rand = new Random();
    
48.             while (true) {
    
49.                 if (rand.nextInt(100) < 2 && enemyTanks.size() < 30) { // 2% chance to spawn an enemy tank, max 30
    
50.                     int side = rand.nextInt(4);
    
51.                     int enemyX = 0, enemyY = 0;
    
52.                     switch (side) {
    
53.                         case 0: // top
    
54.                             enemyX = rand.nextInt(getWidth());
    
55.                             enemyY = 0;
    
56.                             break;
    
57.                         case 1: // right
    
58.                             enemyX = getWidth();
    
59.                             enemyY = rand.nextInt(getHeight());
    
60.                             break;
    
61.                         case 2: // bottom
    
62.                             enemyX = rand.nextInt(getWidth());
    
63.                             enemyY = getHeight();
    
64.                             break;
    
65.                         case 3: // left
    
66.                             enemyX = 0;
    
67.                             enemyY = rand.nextInt(getHeight());
    
68.                             break;
    
69.                     }
    
70.                     enemyTanks.add(new EnemyTank(enemyX, enemyY, rand.nextInt(4), new Color(rand.nextInt(256), rand.nextInt(256), rand.nextInt(256))));
    
71.                 }
    
72.                 moveAndRemoveBullets();
    
73.                 moveEnemyTanks();
    
74.                 checkBulletCollisions();
    
75.                 repaint();
    
76.                 try {
    
77.                     Thread.sleep(10);
    
78.                 } catch (InterruptedException e) {
    
79.                     e.printStackTrace();
    
80.                 }
    
81.             }
    
82.         }).start();
    
83.     }
    
84. 
    
85.     private void handleKeyPress(int keyCode) {
    
86.         switch (keyCode) {
    
87.             case KeyEvent.VK_UP:
    
88.                 if (y - MOVE_DISTANCE >= CANNON_HEIGHT) {
    
89.                     y -= MOVE_DISTANCE;
    
90.                 }
    
91.                 cannonDirection = 0;
    
92.                 break;
    
93.             case KeyEvent.VK_DOWN:
    
94.                 if (y + MOVE_DISTANCE <= getHeight() - TANK_HEIGHT - WHEEL_DIAMETER / 2) {
    
95.                     y += MOVE_DISTANCE;
    
96.                 }
    
97.                 cannonDirection = 2;
    
98.                 break;
    
99.             case KeyEvent.VK_LEFT:
    
100.                 if (x - MOVE_DISTANCE >= WHEEL_DIAMETER / 2) {
     
101.                     x -= MOVE_DISTANCE;
     
102.                 }
     
103.                 cannonDirection = 3;
     
104.                 break;
     
105.             case KeyEvent.VK_RIGHT:
     
106.                 if (x + MOVE_DISTANCE <= getWidth() - TANK_WIDTH - WHEEL_DIAMETER / 2) {
     
107.                     x += MOVE_DISTANCE;
     
108.                 }
     
109.                 cannonDirection = 1;
     
110.                 break;
     
111.             case KeyEvent.VK_SPACE:
     
112.                 if (!spacePressed) {
     
113.                     int bulletX = x + TANK_WIDTH / 2;
     
114.                     int bulletY = y - CANNON_HEIGHT;
     
115.                     switch (cannonDirection) {
     
116.                         case 0: // up
     
117.                             bulletY = y - CANNON_HEIGHT;
     
118.                             break;
     
119.                         case 1: // right
     
120.                             bulletX = x + TANK_WIDTH;
     
121.                             bulletY = y + TANK_HEIGHT / 2;
     
122.                             break;
     
123.                         case 2: // down
     
124.                             bulletX = x + TANK_WIDTH / 2;
     
125.                             bulletY = y + TANK_HEIGHT;
     
126.                             break;
     
127.                         case 3: // left
     
128.                             bulletX = x - CANNON_HEIGHT;
     
129.                             bulletY = y + TANK_HEIGHT / 2;
     
130.                             break;
     
131.                     }
     
132.                     bullets.add(new Bullet(bulletX, bulletY, cannonDirection));
     
133.                     spacePressed = true;
     
134.                 }
     
135.                 break;
     
136.         }
     
137.     }
     
138. 
     
139.     @Override
     
140.     protected void paintComponent(Graphics g) {
     
141.         super.paintComponent(g);
     
142.         drawTank(g, x, y);
     
143.         for (Bullet bullet : bullets) {
     
144.             bullet.draw(g);
     
145.         }
     
146.         for (EnemyTank enemy : enemyTanks) {
     
147.             enemy.draw(g);
     
148.             for (Bullet enemyBullet : enemy.getBullets()) {
     
149.                 enemyBullet.draw(g);
     
150.             }
     
151.         }
     
152.         g.setColor(Color.BLACK);
     
153.         g.drawString("Enemies Defeated: " + enemiesDefeated, 10, 20);
     
154.     }
     
155. 
     
156.     private void drawTank(Graphics g, int x, int y) {
     
157.         g.setColor(Color.YELLOW);
     
158.         g.fillRect(x, y, TANK_WIDTH, TANK_HEIGHT);
     
159.         g.setColor(Color.BLACK);
     
160.         switch (cannonDirection) {
     
161.             case 0: // up
     
162.                 g.fillRect(x + (TANK_WIDTH / 2) - 2, y - CANNON_HEIGHT, 4, CANNON_HEIGHT);
     
163.                 break;
     
164.             case 1: // right
     
165.                 g.fillRect(x + TANK_WIDTH, y + (TANK_HEIGHT / 2) - 2, CANNON_HEIGHT, 4);
     
166.                 break;
     
167.             case 2: // down
     
168.                 g.fillRect(x + (TANK_WIDTH / 2) - 2, y + TANK_HEIGHT, 4, CANNON_HEIGHT);
     
169.                 break;
     
170.             case 3: // left
     
171.                 g.fillRect(x - CANNON_HEIGHT, y + (TANK_HEIGHT / 2) - 2, CANNON_HEIGHT, 4);
     
172.                 break;
     
173.         }
     
174.         g.fillOval(x - WHEEL_DIAMETER / 2, y + TANK_HEIGHT - WHEEL_DIAMETER / 2, WHEEL_DIAMETER, WHEEL_DIAMETER);
     
175.         g.fillOval(x + TANK_WIDTH - WHEEL_DIAMETER / 2, y + TANK_HEIGHT - WHEEL_DIAMETER / 2, WHEEL_DIAMETER, WHEEL_DIAMETER);
     
176.     }
     
177. 
     
178.     private void moveAndRemoveBullets() {
     
179.         for (Bullet bullet : bullets) {
     
180.             bullet.move();
     
181.         }
     
182.         bullets.removeIf(bullet -> bullet.getY() < 0 || bullet.getY() > getHeight() || bullet.getX() < 0 || bullet.getX() > getWidth());
     
183.         for (EnemyTank enemy : enemyTanks) {
     
184.             for (Bullet enemyBullet : enemy.getBullets()) {
     
185.                 enemyBullet.move();
     
186.             }
     
187.             enemy.getBullets().removeIf(bullet -> bullet.getY() < 0 || bullet.getY() > getHeight() || bullet.getX() < 0 || bullet.getX() > getWidth());
     
188.         }
     
189.     }
     
190. 
     
191.     private void moveEnemyTanks() {
     
192.         for (EnemyTank enemy : enemyTanks) {
     
193.             enemy.move(enemyTanks);
     
194.             if (new Random().nextInt(100) < 1) { // 1% chance to shoot
     
195.                 enemy.shoot();
     
196.             }
     
197.         }
     
198.         enemyTanks.removeIf(enemy -> enemy.getX() < 0 || enemy.getX() > getWidth() || enemy.getY() < 0 || enemy.getY() > getHeight());
     
199.     }
     
200. 
     
201.     private void checkBulletCollisions() {
     
202.         Iterator<Bullet> bulletIterator = bullets.iterator();
     
203.         while (bulletIterator.hasNext()) {
     
204.             Bullet bullet = bulletIterator.next();
     
205.             Iterator<EnemyTank> enemyIterator = enemyTanks.iterator();
     
206.             while (enemyIterator.hasNext()) {
     
207.                 EnemyTank enemy = enemyIterator.next();
     
208.                 if (bullet.getX() >= enemy.getX() && bullet.getX() <= enemy.getX() + EnemyTank.ENEMY_TANK_WIDTH &&
     
209.                     bullet.getY() >= enemy.getY() && bullet.getY() <= enemy.getY() + EnemyTank.ENEMY_TANK_HEIGHT) {
     
210.                     enemyIterator.remove();
     
211.                     bulletIterator.remove();
     
212.                     enemiesDefeated++;
     
213.                     break; // Exit the inner loop after removing the enemy tank
     
214.                 }
     
215.             }
     
216.         }
     
217.     }
     
218. 
     
219.     private class Bullet {
     
220.         private int x;
     
221.         private int y;
     
222.         private int direction;
     
223.         private static final int BULLET_SIZE = 3;
     
224.         private static final int BULLET_SPEED = 5;
     
225. 
     
226.         public Bullet(int x, int y, int direction) {
     
227.             this.x = x;
     
228.             this.y = y;
     
229.             this.direction = direction;
     
230.         }
     
231. 
     
232.         public int getX() {
     
233.             return x;
     
234.         }
     
235. 
     
236.         public int getY() {
     
237.             return y;
     
238.         }
     
239. 
     
240.         public void move() {
     
241.             switch (direction) {
     
242.                 case 0: // up
     
243.                     y -= BULLET_SPEED;
     
244.                     break;
     
245.                 case 1: // right
     
246.                     x += BULLET_SPEED;
     
247.                     break;
     
248.                 case 2: // down
     
249.                     y += BULLET_SPEED;
     
250.                     break;
     
251.                 case 3: // left
     
252.                     x -= BULLET_SPEED;
     
253.                     break;
     
254.             }
     
255.         }
     
256. 
     
257.         public void draw(Graphics g) {
     
258.             g.setColor(Color.RED);
     
259.             g.fillOval(x - BULLET_SIZE / 2, y - BULLET_SIZE / 2, BULLET_SIZE, BULLET_SIZE);
     
260.         }
     
261.     }
     
262. 
     
263.     private class EnemyTank {
     
264.         private int x;
     
265.         private int y;
     
266.         private int direction;
     
267.         private Color color;
     
268.         private static final int ENEMY_TANK_WIDTH = 30;
     
269.         private static final int ENEMY_TANK_HEIGHT = 15;
     
270.         private static final int ENEMY_MOVE_DISTANCE = 2;
     
271.         private List<Bullet> bullets = new ArrayList<>();
     
272. 
     
273.         public EnemyTank(int x, int y, int direction, Color color) {
     
274.             this.x = x;
     
275.             this.y = y;
     
276.             this.direction = direction;
     
277.             this.color = color;
     
278.         }
     
279. 
     
280.         public int getX() {
     
281.             return x;
     
282.         }
     
283. 
     
284.         public int getY() {
     
285.             return y;
     
286.         }
     
287. 
     
288.         public List<Bullet> getBullets() {
     
289.             return bullets;
     
290.         }
     
291. 
     
292.         public void move(List<EnemyTank> enemyTanks) {
     
293.             int newX = x;
     
294.             int newY = y;
     
295.             switch (direction) {
     
296.                 case 0: // up
     
297.                     newY -= ENEMY_MOVE_DISTANCE;
     
298.                     break;
     
299.                 case 1: // right
     
300.                     newX += ENEMY_MOVE_DISTANCE;
     
301.                     break;
     
302.                 case 2: // down
     
303.                     newY += ENEMY_MOVE_DISTANCE;
     
304.                     break;
     
305.                 case 3: // left
     
306.                     newX -= ENEMY_MOVE_DISTANCE;
     
307.                     break;
     
308.             }
     
309. 
     
310.             boolean collision = false;
     
311.             for (EnemyTank other : enemyTanks) {
     
312.                 if (other != this && newX < other.getX() + ENEMY_TANK_WIDTH && newX + ENEMY_TANK_WIDTH > other.getX() &&
     
313.                     newY < other.getY() + ENEMY_TANK_HEIGHT && newY + ENEMY_TANK_HEIGHT > other.getY()) {
     
314.                     collision = true;
     
315.                     break;
     
316.                 }
     
317.             }
     
318. 
     
319.             if (!collision) {
     
320.                 x = newX;
     
321.                 y = newY;
     
322.             } else {
     
323.                 direction = new Random().nextInt(4); // 重新选择路线
     
324.             }
     
325.         }
     
326. 
     
327.         public void shoot() {
     
328.             int bulletX = x + ENEMY_TANK_WIDTH / 2;
     
329.             int bulletY = y - CANNON_HEIGHT;
     
330.             switch (direction) {
     
331.                 case 0: // up
     
332.                     bulletY = y - CANNON_HEIGHT;
     
333.                     break;
     
334.                 case 1: // right
     
335.                     bulletX = x + ENEMY_TANK_WIDTH;
     
336.                     bulletY = y + ENEMY_TANK_HEIGHT / 2;
     
337.                     break;
     
338.                 case 2: // down
     
339.                     bulletX = x + ENEMY_TANK_WIDTH / 2;
     
340.                     bulletY = y + ENEMY_TANK_HEIGHT;
     
341.                     break;
     
342.                 case 3: // left
     
343.                     bulletX = x - CANNON_HEIGHT;
     
344.                     bulletY = y + ENEMY_TANK_HEIGHT / 2;
     
345.                     break;
     
346.             }
     
347.             bullets.add(new Bullet(bulletX, bulletY, direction));
     
348.         }
     
349. 
     
350.         public void draw(Graphics g) {
     
351.             g.setColor(color);
     
352.             g.fillRect(x, y, ENEMY_TANK_WIDTH, ENEMY_TANK_HEIGHT);
     
353.             g.setColor(Color.BLACK);
     
354.             switch (direction) {
     
355.                 case 0: // up
     
356.                     g.fillRect(x + (ENEMY_TANK_WIDTH / 2) - 2, y - CANNON_HEIGHT, 4, CANNON_HEIGHT);
     
357.                     break;
     
358.                 case 1: // right
     
359.                     g.fillRect(x + ENEMY_TANK_WIDTH, y + (ENEMY_TANK_HEIGHT / 2) - 2, CANNON_HEIGHT, 4);
     
360.                     break;
     
361.                 case 2: // down
     
362.                     g.fillRect(x + (ENEMY_TANK_WIDTH / 2) - 2, y + ENEMY_TANK_HEIGHT, 4, CANNON_HEIGHT);
     
363.                     break;
     
364.                 case 3: // left
     
365.                     g.fillRect(x - CANNON_HEIGHT, y + (ENEMY_TANK_HEIGHT / 2) - 2, CANNON_HEIGHT, 4);
     
366.                     break;
     
367.             }
     
368.             g.fillOval(x - WHEEL_DIAMETER / 2, y + ENEMY_TANK_HEIGHT - WHEEL_DIAMETER / 2, WHEEL_DIAMETER, WHEEL_DIAMETER);
     
369.             g.fillOval(x + ENEMY_TANK_WIDTH - WHEEL_DIAMETER / 2, y + ENEMY_TANK_HEIGHT - WHEEL_DIAMETER / 2, WHEEL_DIAMETER, WHEEL_DIAMETER);
     
370.         }
     
371.     }
     
372. 
     
373.     public static void main(String[] args) {
     
374.         JFrame frame = new JFrame("可通过方向键移动且发射子弹的坦克");
     
375.         TankMovementWithKeysAndBullets panel = new TankMovementWithKeysAndBullets();
     
376. 
     
377.         frame.add(panel);
     
378.         frame.setSize(400, 400);
     
379.         frame.setVisible(true);
     
380.         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
     
381.         panel.requestFocusInWindow();
     
382.     }
     
383. }

复制代码