初级坦克大战

package com;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.Vector;

class Main extends JFrame {
    MyPanel mp;

    public static void main(String[] args) {
        new Main();
    }

    Main() {
        //new Thread(mp);
        mp = new MyPanel();
        this.add(mp);
        this.setSize(1100, 800);
        this.addKeyListener(mp);
        this.setVisible(true);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    }
}

class Tank {
    private int x;
    private int y;
    private int type;
    private int direct = 0;
    private int speed;
    public static int cnt = 0;

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void moveUp() {
        if(y>0)
        y -= speed;
    }

    public void moveDown() {
        if(y+50<750)
        y += speed;
    }

    public void moveLeft() {
        if(x>0)
        x -= speed;
    }

    public void moveRight() {
        if(x+50<1000)
        x += speed;
    }

    public int getDirect() {
        return direct;
    }

    public void setDirect(int direct) {
        this.direct = direct;
    }

    //坦克的坐标
    public Tank(int x, int y, int type) {
        this.x = x;
        this.y = y;
        this.type = type;
    }

    public int getType() {
        return type;
    }

    public void setType(int type) {
        this.type = type;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

}

class Hero extends Tank {
    Vector<Ball> bullet = new Vector<>();

    public Hero(int x, int y, int type) {
        super(x, y, type);
    }

    int ballNum = 0;
    //控制坦克发射子弹
    Ball ball = null;
    boolean isLive = true;
    public void fire() {
        ball = null;
        switch (getDirect()) {
            case 0:
                ball = new Ball(getX() + 20, getY(), 0);
                break;
            case 1:
                ball = new Ball(getX() + 50, getY() + 20, 1);
                break;
            case 2:
                ball = new Ball(getX() + 20, getY() + 50, 2);
                break;
            case 3:
                ball = new Ball(getX(), getY() + 20, 3);
                break;
        }
        bullet.add(ball);
        new Thread(ball).start();
    }
}

class Enemy extends Tank implements Runnable {
    boolean isLive = true;

    public Enemy(int x, int y, int type) {
        super(x, y, type);
    }
    Ball ball_ = null;
    Vector<Ball> ball = new Vector<>();
    public void fire() {
        ball_ = null;
        switch (getDirect()) {
            case 0:
                ball_ = new Ball(getX() + 20, getY(), 0);
                break;
            case 1:
                ball_ = new Ball(getX() + 50, getY() + 20, 1);
                break;
            case 2:
                ball_ = new Ball(getX() + 20, getY() + 50, 2);
                break;
            case 3:
                ball_ = new Ball(getX(), getY() + 20, 3);
                break;
        }
        ball.add(ball_);
        new Thread(ball_).start();
    }
    @Override
    public void run() {
        while (true) {
            switch (getDirect()) {
                case 0 -> {
                    for (int i = 0; i < 20; i++) {
                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        moveUp();
                    }
                }
                case 1 -> {
                    for (int i = 0; i < 20; i++) {
                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        moveRight();
                    }

                }
                case 2 -> {
                    for (int i = 0; i < 20; i++) {
                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        moveDown();
                    }
                }
                case 3 -> {
                    for (int i = 0; i < 20; i++) {
                        try {
                            Thread.sleep(20);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                        moveLeft();
                    }
                }
            }
            setDirect((int) (Math.random() * 4));

            if (!isLive) {
                break;
            }
        }
    }

}

class Ball implements Runnable {
    int x;
    int y;
    int dir;
    int speed = 10;
    boolean isLive = true;

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public Ball(int x, int y, int dir) {
        this.x = x;
        this.y = y;
        this.dir = dir;
    }

    @Override
    public void run() {
        while (true) {
            switch (dir) {
                case 0:
                    y -= speed;
                    break;
                case 1:
                    x += speed;
                    break;
                case 2:
                    y += speed;
                    break;
                case 3:
                    x -= speed;
                    break;
            }
            try {
                Thread.sleep(50);
                System.out.println(Thread.currentThread().getName() + "   " + x + "   " + y);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            //System.out.println("X= " + x + "   Y="  + y);
            if (!(x >= 0 && x <= 1000 && y >= 0 && y <= 750 && isLive)) {
                System.out.println("子弹已销毁");
                isLive = false;
                break;
            }
        }
    }
}

class MyPanel extends JPanel implements KeyListener, Runnable {
    Hero hero;
    Enemy enemyTank;
    Vector<Squib> squibs = new Vector<>();
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;
    // ***
    Vector<Enemy> enemy = new Vector<>();
    int enemySize = 6;
    static int n = 0; //坦克数量

    public MyPanel() {
        hero = new Hero(100, 300, 0);
        hero.setSpeed(10);
        new Thread(this).start();
        for (int i = 0; i < enemySize; i++) {
            enemyTank = new Enemy(i * 100 + 50, 10, 1);
            enemyTank.setSpeed(3);
            Ball ball_ = new Ball(enemyTank.getX() + 20, enemyTank.getY() + 50, 2);
            enemyTank.ball.add(ball_);
            System.out.println("加入一颗子弹");
            new Thread(ball_).start();
            new Thread(enemyTank).start();
            enemy.add(enemyTank);
        }
        image1 = Toolkit.getDefaultToolkit().getImage(Main.class.getResource("/picture/squib1.png"));
        image2 = Toolkit.getDefaultToolkit().getImage(Main.class.getResource("/picture/squib2.png"));
        image3 = Toolkit.getDefaultToolkit().getImage(Main.class.getResource("/picture/squib3.png"));
        //new Thread(change).start();
    }

    public void paint(Graphics g) {
        super.paint(g);
        g.drawImage(image1, 200, 200, 400, 400, this);
        g.fillRect(0, 0, 1000, 750);
        for (int i = 0; i < enemy.size(); i++) {
            if (enemy.get(i).isLive) {
                // System.out.println(change.dir);
                switch (enemy.get(i).getDirect()) {
                    case 0:
                        enemy.get(i).moveUp();
                        drawUpTank(enemy.get(i).getX(), enemy.get(i).getY(), g, enemy.get(i).getType());
                        break;
                    case 1:
                        enemy.get(i).moveRight();
                        drawRightTank(enemy.get(i).getX(), enemy.get(i).getY(), g, enemy.get(i).getType());
                        break;
                    case 2:
                        enemy.get(i).moveDown();
                        drawDownTank(enemy.get(i).getX(), enemy.get(i).getY(), g, enemy.get(i).getType());
                        break;
                    case 3:
                        enemy.get(i).moveLeft();
                        drawLeftTank(enemy.get(i).getX(), enemy.get(i).getY(), g, enemy.get(i).getType());
                        break;
                }
                System.out.println("坦克的位置：" + enemy.get(i).getX() + "    " + enemy.get(i).getY());
                //drawDownTank(enemy.get(i).getX(), enemy.get(i).getY(), g, enemy.get(i).getType());
                Enemy tank_ = enemy.get(i);
                Vector<Ball> balls = tank_.ball;
                for (int j = 0; j < balls.size(); j++) {
                    Ball ball = balls.get(j);
                    if (ball.isLive) {
                        g.fill3DRect(ball.x, ball.y, 5, 5, false);
                        if(ball.x>hero.getX()&&ball.x<hero.getX()+40 && ball.y>hero.getY()&&ball.y<hero.getY()+50){
                             squibs.add(new Squib(hero.getX(),hero.getY()));
                             hero.isLive = false;
                        }
                    } else {
                        tank_.ball.remove(ball);
                    }
                }
            } else {
                enemy.remove(enemy.get(i));
            }
        }
        // 画坦克
        if(hero.isLive){
            switch (hero.getDirect()) {
                case 0 -> drawUpTank(hero.getX(), hero.getY(), g, hero.getType());
                case 1 -> drawRightTank(hero.getX(), hero.getY(), g, hero.getType());
                case 2 -> drawDownTank(hero.getX(), hero.getY(), g, hero.getType());
                case 3 -> drawLeftTank(hero.getX(), hero.getY(), g, hero.getType());
                default -> {
                }
            }
        }
        //画已方子弹
        for (int i = 0; i < hero.bullet.size(); i++) {
            Ball ball = hero.bullet.get(i);
            if (ball.isLive) {
                for (int j = 0; j < enemy.size(); j++) {
                    Enemy enemy1 = enemy.get(j);

                    if (ball.x >= enemy1.getX() && ball.x <= enemy1.getX() + 40 && ball.y >= enemy1.getY()
                            && ball.y <= enemy1.getY() + 50) {
                        ball.isLive = false;
                        enemy.get(j).isLive = false;
                        squibs.add(new Squib(enemy1.getX(), enemy1.getY()));
                    }
                }
                g.fill3DRect(ball.x, ball.y, 5, 5, false);
            } else {
                hero.bullet.remove(ball);
            }
        }
        //画爆炸效果
        for (int i = 0; i < squibs.size(); i++) {
            Squib tmp1 = squibs.get(i);
            if (tmp1.life > 6) {
                g.drawImage(image1, tmp1.x, tmp1.y, 40, 40, this);
            } else if (tmp1.life > 3) {
                g.drawImage(image2, tmp1.x, tmp1.y, 40, 40, this);
            } else {
                g.drawImage(image3, tmp1.x, tmp1.y, 40, 40, this);
            }

            tmp1.listDown();

            if (tmp1.life == 0)
                squibs.remove(tmp1);
        }
        //画敌方子弹
        for(int i=0;i<enemy.size();i++){
            Vector<Ball> ball = enemy.get(i).ball;
            Enemy enemy1 = enemy.get(i);
            if(ball.size() < 100){
                enemy.get(i).fire();
            }
        }
    }

    public void run() {
        while (true) {
            try {
                Thread.sleep(10);
                this.repaint();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }

    //向上移动的坦克
    public void drawUpTank(int x, int y, Graphics g, int type) {
        switch (type) {
            case 0:
                g.setColor(Color.cyan);
                break;
            case 1:
                g.setColor(Color.yellow);
                break;
        }
        //左
        g.fill3DRect(x, y, 10, 50, false);
        //中
        g.fill3DRect(x + 10, y + 10, 20, 30, false);
        //右
        g.fill3DRect(x + 30, y, 10, 50, false);
        //圆
        g.fillOval(x + 10, y + 20, 20, 10);
        //炮筒
        g.fill3DRect(x + 20, y, 2, 20, false);
        //this.repaint();
    }

    public void drawDownTank(int x, int y, Graphics g, int type) {
        switch (type) {
            case 0:
                g.setColor(Color.cyan);
                break;
            case 1:
                g.setColor(Color.yellow);
                break;
        }
        //左
        g.fill3DRect(x, y, 10, 50, false);
        //中
        g.fill3DRect(x + 10, y + 10, 20, 30, false);
        //右
        g.fill3DRect(x + 30, y, 10, 50, false);
        //圆
        g.fillOval(x + 10, y + 20, 20, 10);
        //炮筒
        g.fill3DRect(x + 20, y + 30, 2, 20, false);
        //this.repaint();
    }

    public void drawRightTank(int x, int y, Graphics g, int type) {
        switch (type) {
            case 0:
                g.setColor(Color.cyan);
                break;
            case 1:
                g.setColor(Color.yellow);
                break;
        }
        g.fill3DRect(x, y, 50, 10, false);
        g.fill3DRect(x + 10, y + 10, 30, 20, false);
        g.fill3DRect(x, y + 30, 50, 10, false);
        g.fillOval(x + 20, y + 10, 10, 20);
        g.fill3DRect(x + 30, y + 20, 20, 2, false);
        //this.repaint();
    }

    public void drawLeftTank(int x, int y, Graphics g, int type) {
        switch (type) {
            case 0:
                g.setColor(Color.cyan);
                break;
            case 1:
                g.setColor(Color.yellow);
                break;
        }
        g.fill3DRect(x, y, 50, 10, false);
        g.fill3DRect(x + 10, y + 10, 30, 20, false);
        g.fill3DRect(x, y + 30, 50, 10, false);
        g.fillOval(x + 20, y + 10, 10, 20);
        g.fill3DRect(x, y + 20, 20, 2, false);
        //this.repaint();
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_DOWN) {
            hero.setDirect(2);
            hero.moveDown();
        } else if (e.getKeyCode() == KeyEvent.VK_UP) {
            hero.setDirect(0);
            hero.moveUp();
        } else if (e.getKeyCode() == KeyEvent.VK_LEFT) {
            hero.setDirect(3);
            hero.moveLeft();
        } else if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
            hero.setDirect(1);
            hero.moveRight();
        }
        if (e.getKeyCode() == KeyEvent.VK_SPACE) {
            if(hero.bullet.size() <=5)
                 hero.fire();
        }
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }
}