Java初学笔记23-【坦克游戏——java部分代码】

• 坦克游戏部分代码
• • 1.Tank
  • 2. MyTank
  • 3. EnemyTank
  • 4. MyBullet
  • 5. EnemyBullet
  • 6. Bullet
  • 7. Bomb
  • 8.TankPanel
  • 9.TankGame04

package project.tankgame04;


public class Tank {
    private int x; //坦克的横坐标
    private int y; //坦克的纵坐标
    private int direction; //坦克方向 0123 上下左右
    private int speed = 3; //坦克速度

    
    private boolean t_sur = true;

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

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

    
    public void moveRight(){
        x += speed;
    }

    
    public void moveDown(){
        y += speed;
    }

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

    
    public void fire(){

    }

    public int getDirection() {
        return direction;
    }

    public void setDirection(int direction) {
        this.direction = direction;
    }

    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;
    }

    public int getSpeed() {
        return speed;
    }

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

    public boolean isT_sur() {
        return t_sur;
    }

    public void setT_sur(boolean t_sur) {
        this.t_sur = t_sur;
    }
}

package project.tankgame04;


import java.util.Vector;


public class MyTank extends Tank {  //继承父类坦克

    
    MyBullet myBullet = null;

    
    Vector myBullets = new Vector<>();

    
    public MyTank(int x, int y) {
        super(x, y);
    }

    
    @Override
    public void fire() {
        //游戏面板控制自己的子弹最多为8个
        if(myBullets.size() == 8){
            return;
        }
        switch (getDirection()){
            case 0:
                myBullet = new MyBullet(getX()+20,getY(),getDirection());
                break;
            case 1:
                myBullet = new MyBullet(getX()+60,getY()+20,getDirection());
                break;
            case 2:
                myBullet = new MyBullet(getX()+20,getY()+60,getDirection());
                break;
            case 3:
                myBullet = new MyBullet(getX(),getY()+20,getDirection());
                break;
        }
        //将自己的子弹线程加入集合
        myBullets.add(myBullet);
        //启动子弹线程
        new Thread(myBullet).start();
    }

}

package project.tankgame04;

import java.util.Vector;


public class EnemyTank extends Tank implements Runnable{
    
    Vector e_Bullets_Ve = new Vector<>();

    
    public EnemyTank(int x, int y) {
        super(x, y);
    }

    @Override
    public void run() {
        while (true){

            //判断此时敌人坦克是否存活，以及坦克里面的子弹线程是否还有
            //使敌人坦克可以发射3颗子弹
            if(isT_sur() && e_Bullets_Ve.size() < 5){

                EnemyBullet  bul = null;
                //根据此时坦克的位置创建敌人子弹线程
                switch (getDirection()){
                    case 0:
                        bul = new EnemyBullet(getX()+20,getY(),0);
                        break;
                    case 1:
                        bul = new EnemyBullet(getX()+60,getY()+20,1);
                        break;
                    case 2:
                        bul = new EnemyBullet(getX()+20,getY()+60,2);
                        break;
                    case 3:
                        bul = new EnemyBullet(getX(),getY()+20,3);
                        break;
                }
                //将敌人子弹线程加入集合
                e_Bullets_Ve.add(bul);
                //启动敌人子弹线程
                new Thread(bul).start();
            }
            switch (getDirection()){
                case 0:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getY() > 0){
                            moveUp();
                        }
                    }
                    break;
                case 1:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getX() + 60 < 1000){
                            moveRight();
                        }
                    }
                    break;
                case 2:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getY() + 60 < 750){
                            moveDown();
                        }
                    }
                    break;
                case 3:
                    for (int i = 0; i < 10; i++) {
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        if(getX() > 0){
                            moveLeft();
                        }
                    }
                    break;
            }

            //为敌人坦克设置随机方向
            setDirection((int)(Math.random()*4));
            //敌人坦克死亡，结束线程
            if(!isT_sur()){
                System.out.println("敌人坦克线程： "+ Thread.currentThread().getName()
                        +" 已经结束");
                break;
            }
        }
    }
}

package project.tankgame04;


public class MyBullet extends Bullet implements Runnable{

    
    public MyBullet(int b_x, int b_y, int b_direction) {
        super(b_x, b_y, b_direction);
    }

    @Override
    public void run() {
        while (true){
            //休眠50毫秒
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //判断自己的子弹方向，沿着这一方向移动
            switch (getB_direction()){
                case 0:
                    setB_y(getB_y()-getB_speed());
                    break;
                case 1:
                    setB_x(getB_x()+getB_speed());
                    break;
                case 2:
                    setB_y(getB_y()+getB_speed());
                    break;
                case 3:
                    setB_x(getB_x()-getB_speed());
                    break;
            }
            System.out.println("我的子弹坐标"+getB_x()+" "+getB_y());
            //如果自己的子弹超出世界边界，或者生命状态在其他地方被设置成false，则
            //设置子弹线程的生命状态为false，并且结束线程
            if(!(getB_x()>=0 && getB_x()<=1000 && getB_y()>=0 &&getB_y()<=750)
                    || isB_sur() == false){
                setB_sur(false);
                System.out.println("我的子弹线程 "+ Thread.currentThread().getName() +" 已经结束");
                break;
            }
        }
    }
}

package project.tankgame04;


public class EnemyBullet extends Bullet implements Runnable{
    
    public EnemyBullet(int b_x, int b_y, int b_direction) {
        super(b_x, b_y, b_direction);
    }

    @Override
    public void run() {
        while (true){
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            switch (getB_direction()){
                case 0:
                    setB_y(getB_y()-getB_speed());
                    break;
                case 1:
                    setB_x(getB_x()+getB_speed());
                    break;
                case 2:
                    setB_y(getB_y()+getB_speed());
                    break;
                case 3:
                    setB_x(getB_x()-getB_speed());
                    break;
            }
            System.out.println("敌人子弹坐标"+getB_x()+" "+getB_y());
            if(!(getB_x()>=0 && getB_x()<=1000 && getB_y()>=0 &&getB_y()<=750)
                    || !isB_sur()){
                setB_sur(false);
                System.out.println("敌人子弹线程 "+ Thread.currentThread().getName() +" 已经结束");
                break;
            }
        }
    }
}

package project.tankgame04;


public class Bullet {
    
    private int b_x;
    
    private int b_y;
    
    private int b_direction;
    
    private int b_speed = 3;
    
    private boolean b_sur = true;

    
    public Bullet(int b_x, int b_y, int b_direction) {
        this.b_x = b_x;
        this.b_y = b_y;
        this.b_direction = b_direction;
    }

    
    public int getB_x() {
        return b_x;
    }

    
    public void setB_x(int b_x) {
        this.b_x = b_x;
    }

    
    public int getB_y() {
        return b_y;
    }

    
    public void setB_y(int b_y) {
        this.b_y = b_y;
    }

    
    public int getB_direction() {
        return b_direction;
    }

    
    public void setB_direction(int b_direction) {
        this.b_direction = b_direction;
    }


    
    public int getB_speed() {
        return b_speed;
    }


    
    public void setB_speed(int b_speed) {
        this.b_speed = b_speed;
    }

    
    public boolean isB_sur() {
        return b_sur;
    }

    
    public void setB_sur(boolean b_sur) {
        this.b_sur = b_sur;
    }
}

package project.tankgame04;


public class Bomb {
    
    int x;

    
    int y;

    
    int life = 9;

    
    boolean isLive = true;

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

    
    public void cutLife(){
        if(isLive && life>=0){
            life--;
        }else{
            isLive = false;
        }
    }
}

package project.tankgame04;

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


public class TankPanel extends JPanel implements KeyListener,Runnable{

    
    MyTank mytank = null;

    
    Vector enemyTanks = new Vector<>();

    
    int enemyTankNum = 3;

    
    Vector bombs = new Vector<>();

    
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    
    public TankPanel(){
        //初始化我的坦克
        mytank = new MyTank(100,600);
        //初始化敌人坦克，默认朝下
        for (int i = 0; i < enemyTankNum; i++) {
            EnemyTank enemyTank = new EnemyTank(100 * (i + 1), 0);
            //初始化敌人的子弹
            EnemyBullet enemyBullet = new EnemyBullet(enemyTank.getX() + 20,
                    enemyTank.getY() + 60, 2);
            //把敌人子弹加入到集合中
            enemyTank.e_Bullets_Ve.add(enemyBullet);
            //启动敌人子弹线程
            new Thread(enemyBullet).start();
            enemyTank.setDirection(2);
            //把敌人坦克加入到集合中
            enemyTanks.add(enemyTank);
            new Thread(enemyTank).start();
        }
        //初始化炸弹特效图片
        image1 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit()
                .getImage(TankPanel.class.getResource("/bomb_3.gif"));
    }

    
    @Override
    public void paint(Graphics g) {
        super.paint(g);
        //默认黑色矩形背景
        g.setColor(Color.BLACK);
        //默认黑色矩形1000 × 750
        g.fillRect(0,0,1000,750);

        //绘制-自己的坦克
        if(mytank != null && mytank.isT_sur()){
            drawTank(mytank.getX(),mytank.getY(),g,mytank.getDirection(),0);
        }

        //绘制敌人的坦克
        //判断敌人坦克集合不为空
        if(enemyTanks != null){
            //遍历敌人坦克集合
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每个敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                //判断每个坦克的生命状态
                if(enemyTank.isT_sur()) {
                    drawTank(enemyTank.getX(), enemyTank.getY(), g,
                            enemyTank.getDirection(), 1);
                }else{
                    //坦克的生命状态为false，除了不绘画之外，还需要在
                    //集合中移除
                    enemyTanks.remove(enemyTank);
                }
            }
        }

        //绘制自己的子弹
        //遍历自己的子弹集合
        if(mytank.myBullets != null){
            for (int i = 0; i < mytank.myBullets.size(); i++) {
                //取出每个子弹
                MyBullet myBullet = mytank.myBullets.get(i);
                //判断子弹的生命状态
                if(myBullet != null && myBullet.isB_sur()){
                    g.setColor(Color.RED);
                    g.fillOval(myBullet.getB_x(),myBullet.getB_y(),5,5);
                }else{
                    mytank.myBullets.remove(myBullet);
                }
            }
        }

        //绘制敌人的子弹
        //判断敌人坦克集合不为空
        if(enemyTanks != null ){
            //遍历敌人坦克集合
            for (int i = 0; i < enemyTanks.size(); i++) {
                //取出每个敌人坦克
                EnemyTank enemyTank = enemyTanks.get(i);
                //判断敌人坦克的子弹集合不为空
                if(enemyTank.e_Bullets_Ve != null){
                    //遍历敌人坦克的子弹集合
                    for (int j = 0; j < enemyTank.e_Bullets_Ve.size(); j++) {
                        //取出每个敌人坦克的子弹
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(j);
                        //判断每个敌人子弹的状态
                        if(enemyBullet.isB_sur()){
                            g.setColor(Color.yellow);
                            g.fillOval(enemyBullet.getB_x(), enemyBullet.getB_y(),
                                    5, 5);
                        }else{
                            //敌人子弹的生命状态为false，除了不绘画之外
                            // 还需要在集合中移除
                            enemyTank.e_Bullets_Ve.remove(enemyBullet);
                        }
                    }
                }
            }
        }

        //绘制炸弹特效
        //遍历炸弹集合
        for (int i = 0; i < bombs.size(); i++) {
            //取出每一个炸弹
            Bomb bomb = bombs.get(i);
            if(bomb.isLive){
                //分阶段绘制炸弹
                if(bomb.life > 6){
                    g.drawImage(image1,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }else if(bomb.life > 3){
                    g.drawImage(image2,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }else{
                    g.drawImage(image3,bomb.x,bomb.y,50,50,this);
                    bomb.cutLife();
                }
            }else{
                bombs.remove(bomb);
            }
        }
    }

    
    public void drawTank(int x, int y, Graphics g,int direct,int type){
        //根据不同类型的坦克，设置不同的颜色
        switch (type){
            case 0://我们的坦克
                g.setColor(Color.pink);
                break;
            case 1: //敌人坦克
                g.setColor(Color.yellow);
                break;
        }

        //根据坦克方向，绘制不同的坦克
        switch (direct){
            case 0: //上
                g.fill3DRect(x,y,10,60,false); //坦克左轮
                g.fill3DRect(x+30,y,10,60,false); //坦克右轮
                g.fill3DRect(x+10,y+10,20,40,false); //坦克身
                g.fillOval(x+10,y+20,20,20); //坦克圆盖
                g.drawLine(x+20,y+30,x+20,y);  //坦克炮筒
                break;
            case 1: //右
                g.fill3DRect(x,y,60,10,false); //坦克上轮
                g.fill3DRect(x,y+30,60,10,false); //坦克下轮
                g.fill3DRect(x+10,y+10,40,20,false); //坦克身
                g.fillOval(x+20,y+10,20,20); //坦克圆盖
                g.drawLine(x+30,y+20,x+60,y+20);  //坦克炮筒
                break;
            case 2: //下
                g.fill3DRect(x,y,10,60,false); //坦克左轮
                g.fill3DRect(x+30,y,10,60,false); //坦克右轮
                g.fill3DRect(x+10,y+10,20,40,false); //坦克身
                g.fillOval(x+10,y+20,20,20); //坦克圆盖
                g.drawLine(x+20,y+30,x+20,y+60);  //坦克炮筒
                break;
            case 3: //左
                g.fill3DRect(x,y,60,10,false); //坦克上轮
                g.fill3DRect(x,y+30,60,10,false); //坦克下轮
                g.fill3DRect(x+10,y+10,40,20,false); //坦克身
                g.fillOval(x+20,y+10,20,20); //坦克圆盖
                g.drawLine(x,y+20,x+30,y+20);  //坦克炮筒
                break;
        }
    }

    
    @Override
    public void keyTyped(KeyEvent e) {

    }

    
    @Override
    public void keyPressed(KeyEvent e) {
        if(e.getKeyCode() == KeyEvent.VK_W){
            mytank.setDirection(0);  //更改坦克的方向
            if(mytank.getY()>0){
                mytank.moveUp(); //使坦克向上走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_D){
            mytank.setDirection(1);
            if(mytank.getX()+60<1000){
                mytank.moveRight(); //使坦克向右走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_S){
            mytank.setDirection(2);
            if(mytank.getY()+60<750){
                mytank.moveDown(); //使坦克向下走
            }
        }else if(e.getKeyCode() == KeyEvent.VK_A){
            mytank.setDirection(3);
            if(mytank.getX()>0){
                mytank.moveLeft(); //使坦克向左走
            }
        }
        //按下J键 子弹射击
        if(mytank != null && mytank.isT_sur()){
            if(e.getKeyCode() == KeyEvent.VK_J){
                mytank.fire();
            }
        }
        this.repaint();
    }

    
    @Override
    public void keyReleased(KeyEvent e) {

    }

    
    @Override
    public void run() {
        while (true){
            //画板隔0.1秒刷新一次
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            killEnenmy();
            killMyTank();
            this.repaint();
        }
    }

    
    public void bitEnenmy(MyBullet myBullet, EnemyTank enemyTank){
        switch (enemyTank.getDirection()){
            case 0:
            case 2:
                if(myBullet.getB_x() >= enemyTank.getX() && myBullet.getB_x() <= enemyTank.getX()+40
                        && myBullet.getB_y() >= enemyTank.getY() && myBullet.getB_y() <= enemyTank.getY()+60 ){
                    //子弹状态：FALSE
                    myBullet.setB_sur(false);
                    //坦克状态：FALSE
                    enemyTank.setT_sur(false);
                    for (int i = 0; i < enemyTank.e_Bullets_Ve.size(); i++) {
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(i);
                        enemyBullet.setB_sur(false);
                    }
                    //把炸弹特效放在敌人位置处，并加入集合
                    bombs.add(new Bomb(enemyTank.getX(),enemyTank.getY()));
                }
                break;
            case 1:
            case 3:
                if(myBullet.getB_x() >= enemyTank.getX() && myBullet.getB_x() <= enemyTank.getX()+60
                        && myBullet.getB_y() >= enemyTank.getY() && myBullet.getB_y() <= enemyTank.getY()+40 ){
                    //子弹状态：FALSE
                    myBullet.setB_sur(false);
                    //坦克状态：FALSE
                    enemyTank.setT_sur(false);
                    for (int i = 0; i < enemyTank.e_Bullets_Ve.size(); i++) {
                        EnemyBullet enemyBullet = enemyTank.e_Bullets_Ve.get(i);
                        enemyBullet.setB_sur(false);
                    }
                    //把炸弹特效放在敌人位置处，并加入集合
                    bombs.add(new Bomb(enemyTank.getX(),enemyTank.getY()));
                }
                break;
        }
    }

    
    public void killEnenmy(){
        //遍历自己的坦克子弹,取出每个子弹
        for (int i = 0; i < mytank.myBullets.size(); i++) {
            MyBullet myBullet = mytank.myBullets.get(i);
            //判断自己的子弹打中敌人
            for (int j = 0; j < enemyTanks.size(); j++) {
                if (enemyTanks != null && myBullet!= null){
                    EnemyTank enemyTank = enemyTanks.get(j);
                    bitEnenmy(myBullet,enemyTank);
                }
            }
        }
    }

    
    public void bitMyTank(EnemyBullet enemyBullet, MyTank mytank){
        if(mytank != null && mytank.isT_sur()) {
            switch (mytank.getDirection()) {
                case 0:
                case 2:
                    if (enemyBullet.getB_x() >= mytank.getX() && enemyBullet.getB_x() <= mytank.getX() + 40
                            && enemyBullet.getB_y() >= mytank.getY() && enemyBullet.getB_y() <= mytank.getY() + 60) {
                        //子弹状态：FALSE
                        enemyBullet.setB_sur(false);
                        //坦克状态：FALSE
                        mytank.setT_sur(false);
                        for (int i = 0; i < mytank.myBullets.size(); i++) {
                            MyBullet myBullet = mytank.myBullets.get(i);
                            myBullet.setB_sur(false);
                        }
                        //把炸弹特效放在自己位置处，并加入集合
                        bombs.add(new Bomb(mytank.getX(), mytank.getY()));
                    }
                    break;
                case 1:
                case 3:
                    if (enemyBullet.getB_x() >= mytank.getX() && enemyBullet.getB_x() <= mytank.getX() + 60
                            && enemyBullet.getB_y() >= mytank.getY() && enemyBullet.getB_y() <= mytank.getY() + 40) {
                        //子弹状态：FALSE
                        enemyBullet.setB_sur(false);
                        //坦克状态：FALSE
                        mytank.setT_sur(false);
                        for (int i = 0; i < mytank.myBullets.size(); i++) {
                            MyBullet myBullet = mytank.myBullets.get(i);
                            myBullet.setB_sur(false);
                        }
                        //把炸弹特效放在自己位置处，并加入集合
                        bombs.add(new Bomb(mytank.getX(), mytank.getY()));
                    }
                    break;
            }
        }
    }

    
    public void killMyTank(){
        //先遍历敌人的坦克
        for (int i = 0; i < enemyTanks.size(); i++) {
            //取出每个敌人坦克
            EnemyTank enemyTank = enemyTanks.get(i);
            //遍历每个敌人坦克里面的每个子弹线程
            for (int j = 0; j < enemyTank.e_Bullets_Ve.size(); j++) {
                EnemyBullet bullet = enemyTank.e_Bullets_Ve.get(j);
                bitMyTank(bullet,mytank);
            }
        }
    }
}

package project.tankgame04;

import javax.swing.*;


public class TankGame04 extends Jframe {

    TankPanel tankPanel01 = null; //先定义一个空的1.0“画板”

    public static void main(String[] args) {
        TankGame04 tankGame01 = new TankGame04();
    }

    
    public TankGame04(){
        tankPanel01 = new TankPanel(); //初始化1.0“画板”
        this.add(tankPanel01);  //添加1.0“画板”
        this.setSize(1000,750); //设置“画板”大小
        this.setVisible(true); //设置“画板”可见
        this.setDefaultCloseOperation(Jframe.EXIT_ON_CLOSE); //点×关闭
        this.addKeyListener(tankPanel01);
        new Thread(tankPanel01).start();
    }
}