Java坦克大战（四）

这是我的坦克游戏大战的最后一版，里面添加很多新的功能。这个坦克大战的有很多不足之处，但是对于初学者来说依然是一个很好的练习项目，从中我们可以学习Java基础知识，将知识与项目结合，学习面向对象编程思想，最主要的是编程的逻辑练习，代码往往不像是写文章从上到下一气呵成完成，中间很可能为增加一个功能来添加一个类一个方法等，中间有很多细节需要我们考虑。文章最后会附加该坦克大战涉及的相关素材。

功能：

1.防止坦克重叠

2.可以分关（闪烁效果）

3.记录成绩（小型游戏都是写在文件中）

4.存盘退出，可以记录但是敌人坦克的坐标

5.可以恢复上局，继续玩

6.坦克的声音

坦克大战最终版本（2.1）

MyTanKGame类：

/*
 * 功能：
 * 1.防止坦克重叠
 * 2.可以分关（闪烁效果）
 * 3.记录成绩（小型游戏都是写在文件中）
 * 4.存盘退出，可以记录但是敌人坦克的坐标
 * 5.可以恢复上局，继续玩
 * 6.坦克的声音
 */
package com.fanghua6;

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

public class MyTankGame1_7 extends JFrame implements ActionListener {

    Mypanel1_2 mp = null;

    // 定义开始面板
    MyStartPanel msp = null;
    // 做出菜单
    JMenuBar jmb = null;
    // 开始游戏
    JMenu jm1 = null;
    JMenuItem jmi1 = null;
    // 退出游戏
    JMenuItem jmi2 = null;
    // 存盘退出
    JMenuItem jmi3 = null;
    JMenuItem jmi4 = null;

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

    // 构造函数
    public MyTankGame1_7() {
        // mp = new Mypanel1_2();

        // 启动mp线程
        // Thread t = new Thread(mp);
        // t.start();

        // this.add(mp);
        // 注册监听
        // this.addKeyListener(mp);
        // 创建菜单及菜单选项
        jmb = new JMenuBar();
        jm1 = new JMenu("游戏（G）");
        jm1.setMnemonic(‘G‘);
        jmi1 = new JMenuItem("开始新游戏（N）");
        jmi1.setMnemonic(‘N‘);

        jmi2 = new JMenuItem("退出游戏（E）");
        jmi2.setMnemonic(‘E‘);

        jmi3 = new JMenuItem("存盘退出（C）");
        jmi3.setMnemonic(‘C‘);

        jmi4 = new JMenuItem("继续上局（S）");
        jmi4.setMnemonic(‘S‘);

        // jmi1相应
        jmi1.addActionListener(this);
        jmi1.setActionCommand("newgame");
        jmi2.addActionListener(this);
        jmi2.setActionCommand("exit");
        jmi3.addActionListener(this);
        jmi3.setActionCommand("saveExit");
        jmi4.addActionListener(this);
        jmi4.setActionCommand("conGame");

        jm1.add(jmi1);
        jm1.add(jmi2);
        jm1.add(jmi3);
        jm1.add(jmi4);

        jmb.add(jm1);

        // 加了开始面板(上面的全注释掉)
        msp = new MyStartPanel();
        this.add(msp);
        // 启动msp面板
        Thread t = new Thread(msp);
        t.start();

        this.setJMenuBar(jmb);

        this.setSize(600, 500);
        this.setTitle("我的坦克大战");
        ImageIcon icon = new ImageIcon("images\\tanke.png");
        this.setIconImage(icon.getImage());
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);

    }

    @Override
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        // 对用户不同的点击做出不同的处理
        if (e.getActionCommand().equals("newgame")) {

            // 创建战场面板
            mp = new Mypanel1_2("newGame");
            // 启动mp线程
            Thread t = new Thread(mp);
            t.start();
            // 先把msp删掉，再加mp
            this.remove(msp);
            this.add(mp);
            // 注册监听
            this.addKeyListener(mp);
            // 显示，刷新JFrame(这个很重要)
            this.setVisible(true);
        } else if (e.getActionCommand().equals("exit")) {

            // 用户退出系统的菜单（保存击毁敌人数量）
            Recorder.keepRecording();

            System.exit(0);
        }// 对存盘退出的处理
        else if (e.getActionCommand().equals("saveExit")) {

            /*
             * 当时这里这样处理的，大错特错。new两次 工作 new Recorder().setEts(mp.ets);new
             * 保存击毁敌人的数量和敌人的坐标 Recorder().keepRecAndEnemyTank();
             */

            // 工作
            Recorder rd = new Recorder();
            rd.setEts(mp.ets);
            // 保存击毁敌人的数量和敌人的坐标
            rd.keepRecAndEnemyTank();

            // 退出
            System.exit(0);
        } else if (e.getActionCommand().equals("conGame")) {
            // 继续游戏
            // 创建战场面板
            mp = new Mypanel1_2("con");

            // 不在这：mp.nodes = new Recorder().getNodesAndEnNums();
            // 启动mp线程
            Thread t = new Thread(mp);
            t.start();
            // 先把msp删掉，再加mp
            this.remove(msp);
            this.add(mp);
            // 注册监听
            this.addKeyListener(mp);
            // 显示，刷新JFrame(这个很重要)
            this.setVisible(true);

        }
    }
}

// 提示面板（用线程来实现闪烁效果）
class MyStartPanel extends JPanel implements Runnable {
    // 做一个开关
    int times = 0;

    public void paint(Graphics g) {
        super.paint(g);
        g.fillRect(0, 0, 400, 300);
        // 提示信息
        if (times % 2 == 0) {
            g.setColor(Color.yellow);
            // 开关信息的字体
            Font myFont = new Font("华文新魏", Font.BOLD, 30);
            g.setFont(myFont);// 别忘了
            g.drawString("stage: 1", 140, 200);
        }
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            // 休眠
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            times++;
            // 重画
            this.repaint();
        }
    }

}

// 我的面板，拓宽思路：Panel本身就是一个刷新体
class Mypanel1_2 extends JPanel implements java.awt.event.KeyListener, Runnable {

    // 定义我的坦克
    Hero1_2 hero = null;

    // 判断是续上局，还是新游戏

    // 定义敌人的坦克（不止一辆，线程安全,集合）
    Vector<EnemyTank> ets = new Vector<EnemyTank>();
    Vector<Node> nodes = new Vector<Node>();

    // 定义炸弹集合
    Vector<Bomb> bombs = new Vector<Bomb>();

    int enSize = 4;// 敌人坦克保持4个

    // 定义三张图片(三张图片才能组成一颗炸弹)
    Image image1 = null;
    Image image2 = null;
    Image image3 = null;

    // 构造函数(续局，变成含参的构造函数)
    public Mypanel1_2(String flag) {

        // 恢复记录(写在这里)
        Recorder.getRecoring();

        hero = new Hero1_2(70, 100);

        if (flag.equals("newGame")) {
            // 初始化敌人的坦克
            for (int i = 0; i < enSize; i++) {
                // 创建一辆敌人的坦克
                EnemyTank et = new EnemyTank((i + 1) * 50, 0);
                et.setColor(0);
                // 坦克默认反向是0（向上），这里改一下
                et.setDirect(2);

                // 将MyPanel的敌人坦克向量交给该敌人坦克
                et.setEts(ets);

                // 启动敌人的坦克
                Thread t = new Thread(et);
                t.start();
                // 给敌人坦克添加一颗子弹
                Shot s = new Shot(et.x + 10, et.y + 30, 2);
                // 加入给敌人的坦克
                et.ss.add(s);

                Thread t2 = new Thread(s);
                t2.start();
                ets.add(et);
            }
        } else {

            nodes = new Recorder().getNodesAndEnNums();

            for (int i = 0; i < nodes.size(); i++) {

                Node node = nodes.get(i);
                // 创建一辆敌人的坦克
                EnemyTank et = new EnemyTank(node.x, node.y);
                et.setColor(0);
                et.setDirect(node.direct);

                // 将MyPanel的敌人坦克向量交给该敌人坦克
                et.setEts(ets);

                // 启动敌人的坦克
                Thread t = new Thread(et);
                t.start();
                // 给敌人坦克添加一颗子弹
                Shot s = new Shot(et.x + 10, et.y + 30, 2);
                // 加入给敌人的坦克
                et.ss.add(s);

                Thread t2 = new Thread(s);
                t2.start();
                ets.add(et);
            }
        }
        // 初始话图片，这样做击中第一个坦克，爆炸的效果不明显。下面优化
        image1 = Toolkit.getDefaultToolkit().getImage(
                Panel.class.getResource("/bomb_1.gif"));
        image2 = Toolkit.getDefaultToolkit().getImage(
                Panel.class.getResource("/bomb_2.gif"));
        image3 = Toolkit.getDefaultToolkit().getImage(
                Panel.class.getResource("/bomb_3.gif"));

        // 引包：import javax.imageio.ImagesssIO;
        // try {
        // image1=ImageIO.read(new File("/bomsb_1.gif"));
        // image2=ImageIO.read(new File("/bomb_2.gif"));
        // image3=ImageIO.read(new File("/bomb_3.gif"));
        // } catch (IOException e) {
        // // TODO Auto-generated catch block
        // e.printStackTrace();
        // }

        // 在Mypanel1_2初始化里，放置开战音效，加载即播放
        // 以后再添加爆炸效果的声音也是这样做的思路
        AePlayWave apw = new AePlayWave("E:\\111.wav");
        apw.start();

    }

    // 提示信息(只需要画笔即可)
    public void showInfo(Graphics g) {
        // 画出提示信息坦克
        this.drawTank(70, 310, g, 0, 0);
        g.setColor(Color.black);
        g.drawString(Recorder.getEnNum() + "", 100, 330);

        this.drawTank(70, 360, g, 0, 1);
        g.setColor(Color.black);
        g.drawString(Recorder.getMyLife() + "", 100, 380);

        // 画出玩家的总成绩
        g.setColor(Color.black);
        Font f = new Font("宋体", Font.BOLD, 20);
        g.setFont(f);
        g.drawString("你的总成绩", 410, 30);
        this.drawTank(410, 60, g, 0, 0);

        g.setColor(Color.black);
        g.drawString(Recorder.getAllEnNum() + "", 440, 80);
    }

    // 重写paint函数
    public void paint(Graphics g) {
        // 一定要调用
        super.paint(g);
        g.fillRect(0, 0, 400, 300);
        // 画出提示信息
        this.showInfo(g);

        // 画出自己的坦克(将方向填进去)
        if (hero.isLive == true) {
            this.drawTank(hero.getX(), hero.getY(), g, this.hero.direct, 1);
        }
        // 从ss中取出每一颗子弹，并画出
        for (int i = 0; i < hero.ss.size(); i++) {

            Shot myShot = hero.ss.get(i);
            if (myShot != null && myShot.isLive == true) {
                g.draw3DRect(myShot.x, myShot.y, 1, 1, false);

                /*
                 * 画出一颗子弹(后添加 hero.s.isLive==true,节省资源) if (hero.s != null
                 * &&hero.s.isLive == true) { g.draw3DRect(hero.s.x, hero.s.y,
                 * 1, 1,false); }
                 */
            }
            if (myShot.isLive == false) {
                // 从ss(向量)中删除该子弹
                // hero.ss.remove(i);会报异常。
                hero.ss.remove(myShot);
            }
        }

        // 画出炸弹
        for (int i = 0; i < bombs.size(); i++) {
            // 取出炸弹
            Bomb b = bombs.get(i);
            if (b.life > 6) {
                g.drawImage(image1, b.x, b.y, 30, 30, this);
            } else if (b.life > 4) {
                g.drawImage(image2, b.x, b.y, 30, 30, this);
            } else {
                g.drawImage(image3, b.x, b.y, 30, 30, this);
            }
            // 让b的生命值减小
            b.lifeDown();
            // 如果炸弹生命值为零，就把该炸弹从bombs向量中去掉
            if (b.life == 0) {
                bombs.remove(b);
            }

        }

        // 画出敌人的坦克
        for (int i = 0; i < ets.size(); i++) {
            EnemyTank et = ets.get(i);
            if (et.isLive) {
                this.drawTank(et.getX(), et.getY(), g, et.getDirect(), 0);

                // 画出敌人的子弹
                for (int j = 0; j < et.ss.size(); j++) {
                    // 取出子弹
                    Shot enemyShot = et.ss.get(j);
                    if (enemyShot != null && enemyShot.isLive == true) {
                        g.draw3DRect(enemyShot.x, enemyShot.y, 1, 1, false);
                    }
                    if (enemyShot.isLive == false) {
                        // 如果敌人的坦克死亡了，就从Vector中删除
                        et.ss.remove(enemyShot);
                    }
                }
            }
        }
    }

    // 敌人的坦克是否击中我
    public void hitMe() {
        // 取出每一个敌人的坦克
        for (int i = 0; i < this.ets.size(); i++) {
            // 取出坦克
            EnemyTank et = ets.get(i);

            // 取出每一颗子弹
            for (int j = 0; j < et.ss.size(); j++) {
                // 取出子弹
                Shot enemyShot = et.ss.get(j);
                if (hero.isLive) {
                    if (this.hitTank(enemyShot, hero)) {

                    }
                }
            }
        }
    }

    // 判断我的子弹是否击中敌人的坦克
    public void hitEnemyTank() {
        // 判断是否击中敌人的坦克
        for (int i = 0; i < hero.ss.size(); i++) {
            // 取出子弹
            Shot myShot = hero.ss.get(i);
            // 判断子弹是否有效
            if (myShot.isLive) {
                // 取出每个坦克，与它判断
                for (int j = 0; j < ets.size(); j++) {
                    // 取出坦克
                    EnemyTank et = ets.get(j);

                    if (et.isLive) {
                        if (this.hitTank(myShot, et)) {

                            // 减少敌人数量
                            Recorder.reduceEnNum();
                            // 增加我的记录
                            Recorder.addEnNumRec();
                        }
                    }

                }
            }
        }
    }

    // 写一个函数 专门判断是否击中敌人坦克(原来第二参数： EnemyTank et)
    // void改成boolean 判断击中的目标是谁

    public boolean hitTank(Shot s, Tank1_2 et) {
        boolean b2 = false;

        // 判断该坦克的方向
        switch (et.direct) {
        // 如果敌人坦克的方向是上或者是下
        case 0:
        case 2:
            if (s.x > et.x && s.x < et.x + 20 && s.y > et.y && s.y < et.y + 30) {
                // 击中
                // 子弹死亡
                s.isLive = false;
                // 敌人坦克死亡
                et.isLive = false;
                b2 = true;
                // 创建一颗炸弹,放入Vector
                Bomb b = new Bomb(et.x, et.y);
                // 放入Vector
                bombs.add(b);

            }

            break;
        case 1:
        case 3:
            if (s.x > et.x && s.x < et.x + 30 && s.y > et.y && s.y < et.y + 20) {
                // 击中
                // 子弹死亡
                s.isLive = false;
                // 敌人坦克死亡
                et.isLive = false;
                b2 = true;
                // 创建一颗炸弹,放入Vector
                Bomb b = new Bomb(et.x, et.y);
                // 放入Vector
                bombs.add(b);

            }
            break;
        }

        return b2;

    }

    // 画出坦克的函数
    public void drawTank(int x, int y, Graphics g, int direct, int type) {
        // 坦克类型
        switch (type) {
        case 0:
            g.setColor(Color.green);
            break;
        case 1:
            g.setColor(Color.yellow);
            break;
        }
        // 方向设置
        switch (direct) {
        // 向上
        case 0:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y);
            break;
        // 向右
        case 1:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x + 30, y + 10);
            break;
        // 向下
        case 2:
            g.fill3DRect(x, y, 5, 30, false);
            g.fill3DRect(x + 15, y, 5, 30, false);
            g.fill3DRect(x + 5, y + 5, 10, 20, false);
            g.fillOval(x + 5, y + 10, 10, 10);
            g.drawLine(x + 10, y + 15, x + 10, y + 30);
            break;
        // 向左
        case 3:
            g.fill3DRect(x, y, 30, 5, false);
            g.fill3DRect(x, y + 15, 30, 5, false);
            g.fill3DRect(x + 5, y + 5, 20, 10, false);
            g.fillOval(x + 10, y + 5, 10, 10);
            g.drawLine(x + 15, y + 10, x, y + 10);
            break;
        }

    }

    @Override
    public void keyPressed(KeyEvent e) {
        // TODO Auto-generated method stub
        // 已更正为顺时针
        if (e.getKeyCode() == KeyEvent.VK_UP || e.getKeyCode() == KeyEvent.VK_W) {
            this.hero.moveUp();
            this.hero.setDirect(0);
        } else if (e.getKeyCode() == KeyEvent.VK_RIGHT
                || e.getKeyCode() == KeyEvent.VK_D) {
            this.hero.setDirect(1);
            this.hero.moveRight();
        } else if (e.getKeyCode() == KeyEvent.VK_DOWN
                || e.getKeyCode() == KeyEvent.VK_S) {
            this.hero.moveDown();
            this.hero.setDirect(2);
        } else if (e.getKeyCode() == KeyEvent.VK_LEFT
                || e.getKeyCode() == KeyEvent.VK_A) {
            this.hero.moveLeft();
            this.hero.setDirect(3);
        } else if (e.getKeyCode() == KeyEvent.VK_J) {
            // 将J键设置为发出子弹
            // 子弹连发，J被按几下，发几颗：this.hero.shotEnemy();
            // this.repaint();在run函数里，不应该设计在这里
            if (this.hero.ss.size() <= 4) {
                this.hero.shotEnemy();
            }
        }
        // 必须重新绘制Panel
        this.repaint();
    }

    @Override
    public void keyReleased(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void keyTyped(KeyEvent e) {
        // TODO Auto-generated method stub

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        // 每隔100毫秒去重绘
        while (true) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // 谨记这里：由于这里多写了这些，线程每次都被重新调用
            // showInfo的信息不会动态改变 调了好久好久。苦笑脸
            // 判断是否击中（写在这里,虽然在每次重绘的时候都要调用，但是没办法）
            // 每一颗子弹都要和每个坦克进行匹配
            // for (int i = 0; i < hero.ss.size(); i++) {
            // // 取出子弹
            // Shot myShot = hero.ss.get(i);
            // // 判断子弹是否有效
            // if (myShot.isLive) {
            // // 取出每个坦克，与它判断
            // for (int j = 0; j < ets.size(); j++) {
            // // 取出坦克
            // EnemyTank et = ets.get(j);
            //
            // if (et.isLive) {
            // this.hitTank(myShot, et);
            // }
            // }
            // }
            // }
            this.hitEnemyTank();

            this.hitMe();

            // 重绘
            this.repaint();
        }
    }
}

Menbers类：

package com.fanghua6;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Vector;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.SourceDataLine;

//播放声音的类
class AePlayWave extends Thread {

    private String filename;

    public AePlayWave(String wavfile) {
        filename = wavfile;

    }

    public void run() {

        File soundFile = new File(filename);

        AudioInputStream audioInputStream = null;
        try {
            audioInputStream = AudioSystem.getAudioInputStream(soundFile);
        } catch (Exception e1) {
            e1.printStackTrace();
            return;
        }

        AudioFormat format = audioInputStream.getFormat();
        SourceDataLine auline = null;
        DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);

        try {
            auline = (SourceDataLine) AudioSystem.getLine(info);
            auline.open(format);
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }

        auline.start();
        int nBytesRead = 0;
        // 这是缓冲
        byte[] abData = new byte[512];

        try {
            while (nBytesRead != -1) {
                nBytesRead = audioInputStream.read(abData, 0, abData.length);
                if (nBytesRead >= 0)
                    auline.write(abData, 0, nBytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
            return;
        } finally {
            auline.drain();
            auline.close();
        }
    }
}

// 继续上一局的记记录点的类
class Node {
    int x;
    int y;
    int direct;

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

// 记录类，同时也可以保存玩家的设置（一般都是事先写在缓存里面的）
class Recorder {
    // 记录每关有多少敌人
    private static int enNum = 20;
    // 设置我有多少可以用的坦克
    private static int myLife = 3;
    // 记录一共消灭多少敌人
    private static int allEnNum = 0;

    // 从文件中恢复记录点
    static Vector<Node> nodes = new Vector<Node>();

    private static FileWriter fw = null;
    private static BufferedWriter bw = null;
    private static FileReader fr = null;
    private static BufferedReader br = null;

    private Vector<EnemyTank> ets = new Vector<EnemyTank>();

    // 完成读取的函数（记录点和敌人的数量）
    public Vector<Node> getNodesAndEnNums() {
        try {
            fr = new FileReader("E:/Tanke.txt");
            br = new BufferedReader(fr);
            String n = "";
            n = br.readLine();// 设置先读第一行
            allEnNum = Integer.parseInt(n);
            // 接着读
            while ((n = br.readLine()) != null) {
                String[] xyz = n.split(" ");
                // 在知道只有三条数据的情况下，用了这个方法。否则要用for循环
                Node node = new Node(Integer.parseInt(xyz[0]),
                        Integer.parseInt(xyz[1]), Integer.parseInt(xyz[2]));
                nodes.add(node);
            }

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                br.close();
                fr.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return nodes;
    }

    public Vector<EnemyTank> getEts() {
        return ets;
    }

    public void setEts(Vector<EnemyTank> ets) {
        this.ets = ets;
    }

    // 保存击毁敌人的数量和击毁敌人坦克的坐标、方向
    public void keepRecAndEnemyTank() {
        try {
            fw = new FileWriter("E:/Tanke.txt");
            bw = new BufferedWriter(fw);

            bw.write(allEnNum + "\r\n");

            // 保存当前的敌人坦克的坐标和方向
            for (int i = 0; i < ets.size(); i++) {
                // 取出第一个坦克
                EnemyTank et = ets.get(i);
                if (et.isLive) {
                    // 活的就保存
                    String recode = et.x + " " + et.y + " " + et.direct;
                    // 写入
                    bw.write(recode + "\r\n");

                }
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                bw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                fw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    // 从文件中读取，记录
    public static void getRecoring() {
        try {
            fr = new FileReader("E:/Tanke.txt");
            br = new BufferedReader(fr);
            String n = br.readLine();
            allEnNum = Integer.parseInt(n);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                br.close();
                fr.close();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

    // 把玩家击毁敌人坦克数量保存到文件中
    public static void keepRecording() {
        try {
            fw = new FileWriter("E:/Tanke.txt");
            bw = new BufferedWriter(fw);

            bw.write(allEnNum + "\r\n");
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                bw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                fw.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

    public static int getAllEnNum() {
        return allEnNum;
    }

    public static void setAllEnNum(int allEnNum) {
        Recorder.allEnNum = allEnNum;
    }

    public static int getEnNum() {
        return enNum;
    }

    public static void setEnNum(int enNum) {
        Recorder.enNum = enNum;
    }

    public static int getMyLife() {
        return myLife;
    }

    public void setMyLife(int myLife) {
        Recorder.myLife = myLife;
    }

    // 减少敌人数
    public static void reduceEnNum() {
        enNum--;
    }

    // 消灭敌人
    public static void addEnNumRec() {
        allEnNum++;
    }

}

// 炸弹类(没必要定义为线程，因为它不会移动，没有坐标改变)
class Bomb {
    // 定义炸弹的坐标
    int x, y;
    int life = 9;// 炸弹的生命(三张图片)
    // 可以看出isLive很有用，它可以决定类（或者对象）要不要展现在面板上
    boolean isLive = true;

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

    // 炸弹减少生命值
    public void lifeDown() {
        if (life > 0) {
            life--;
        } else {
            this.isLive = false;
        }
    }

}

// 子弹类
class Shot implements Runnable {
    int x;
    int y;
    int direct;
    // 设置子弹的消亡（默认活着的）
    boolean isLive = true;
    // speed要给个初始值1，之前给0，按J键，子弹没有动
    int speed = 1;

    public Shot(int x, int y, int direct) {
        super();
        this.x = x;
        this.y = y;
        this.direct = direct;

    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

        while (true) {
            // 设置子弹休息50毫秒

            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            switch (direct) {
            case 0:
                y -= speed;
                break;
            case 1:
                x += speed;
                break;
            case 2:
                y += speed;
                break;
            case 3:
                x -= speed;
                break;
            }
            // 测试用：System.out.println("子弹坐标x=" + x + "y=" + y);
            // 子弹什么时候死亡
            // 判断该子弹是否碰到边缘
            if (x < 0 || x > 400 || y < 0 || y > 300) {
                this.isLive = false;
                break;
            }
        }
    }
}

// 坦克类
class Tank1_2 {

    int x = 0;
    int y = 0;
    boolean isLive = true;

    // 坦克方向：0表示上，1表示右，2表示下，3表示左
    int direct = 0;
    int speed = 1;
    // 坦克的颜色
    int color;

    public int getColor() {
        return color;
    }

    public void setColor(int color) {
        this.color = color;
    }

    public int getSpeed() {
        return speed;
    }

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

    public int getDirect() {
        return direct;
    }

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

    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 Tank1_2(int x, int y) {
        this.x = x;
        this.y = y;

    }

}

// 敌人的坦克(做成线程，会移动)
class EnemyTank extends Tank1_2 implements Runnable {

    int times = 0;
    // 定义一个向量，可以访问MyPanel上所有敌人的坦克
    Vector<EnemyTank> ets = new Vector<EnemyTank>();
    // 定义向量，可以存放敌人的子弹
    Vector<Shot> ss = new Vector<Shot>();

    // 敌人添加子弹，应该刚刚创建坦克和敌人子弹死亡后

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

    // 得到MyPaneld的敌人坦克向量
    public void setEts(Vector<EnemyTank> vv) {
        // 此时拥有一种能力，可以拿到yPan el上所有敌人的坦克
        this.ets = vv;
    }

    // 判断是否碰到别的敌人的坦克
    public boolean isTouchOtherEnemy() {
        boolean b = false;

        switch (this.direct) {
        case 0:
            // 我的坦克向上
            for (int i = 0; i < ets.size(); i++) {
                // 取出第一个坦克(很有可能是自己哦)
                EnemyTank et = ets.get(i);
                // 如果不是自己
                if (et != this) {
                    // 如果敌人的方向是向下或者向下
                    if (et.direct == 0 || et.direct == 2) {
                        if (this.x >= et.x && this.x <= et.x + 20
                                && this.y >= et.y && this.y <= et.y + 30) {
                            return true;
                        }
                        if (this.x + 20 >= et.x && this.x + 20 <= et.x + 20
                                && this.y >= et.y && this.y <= et.y + 30) {
                            return true;
                        }
                    }
                    if (et.direct == 1 || et.direct == 3) {
                        if (this.x >= et.x && this.x <= et.x + 30
                                && this.y >= et.y && this.y <= et.y + 20) {
                            return true;
                        }
                        if (this.x + 20 >= et.x && this.x + 20 <= et.x + 30
                                && this.y >= et.y && this.y <= et.y + 20) {
                            return true;
                        }
                    }
                }
            }
            break;
        case 1:
            for (int i = 0; i < ets.size(); i++) {
                EnemyTank et = ets.get(i);
                if (et != this) {
                    if (et.direct == 0 || et.direct == 2) {
                        if (this.x + 30 >= et.x && this.x + 30 <= et.x + 20
                                && this.y >= et.y && this.y <= et.y + 30) {
                            return true;
                        }
                        if (this.x + 30 >= et.x && this.x + 30 <= et.x + 20
                                && this.y + 20 >= et.y
                                && this.y + 20 <= et.y + 30) {
                            return true;
                        }
                    }
                    if (et.direct == 1 || et.direct == 3) {
                        if (this.x + 30 >= et.x && this.x + 30 <= et.x + 30
                                && this.y >= et.y && this.y <= et.y + 20) {
                            return true;
                        }
                        if (this.x + 30 >= et.x && this.x + 30 <= et.x + 30
                                && this.y + 20 >= et.y
                                && this.y + 20 <= et.y + 20) {
                            return true;
                        }
                    }
                }
            }
            break;
        case 2:
            for (int i = 0; i < ets.size(); i++) {
                EnemyTank et = ets.get(i);
                if (et != this) {
                    if (et.direct == 0 || et.direct == 2) {
                        if (this.x >= et.x && this.x <= et.x + 20
                                && this.y + 30 >= et.y
                                && this.y + 30 <= et.y + 30) {
                            return true;
                        }
                        if (this.x + 20 >= et.x && this.x + 20 <= et.x + 20
                                && this.y + 30 >= et.y
                                && this.y + 30 <= et.y + 30) {
                            return true;
                        }
                    }
                    if (et.direct == 1 || et.direct == 3) {
                        if (this.x >= et.x && this.x <= et.x + 30
                                && this.y + 30 >= et.y
                                && this.y + 30 <= et.y + 20) {
                            return true;
                        }
                        if (this.x + 20 >= et.x && this.x + 20 <= et.x + 30
                                && this.y + 30 >= et.y
                                && this.y + 30 <= et.y + 20) {
                            return true;
                        }
                    }
                }
            }
            break;
        case 3:
            for (int i = 0; i < ets.size(); i++) {
                EnemyTank et = ets.get(i);
                if (et != this) {
                    if (et.direct == 0 || et.direct == 2) {
                        if (this.x >= et.x && this.x <= et.x + 20
                                && this.y >= et.y && this.y <= et.y + 30) {
                            return true;
                        }
                        if (this.x >= et.x && this.x <= et.x + 20
                                && this.y + 20 >= et.y
                                && this.y + 20 <= et.y + 30) {
                            return true;
                        }
                    }
                    if (et.direct == 1 || et.direct == 3) {
                        if (this.x >= et.x && this.x <= et.x + 30
                                && this.y >= et.y && this.y <= et.y + 20) {
                            return true;
                        }
                        if (this.x >= et.x && this.x <= et.x + 30
                                && this.y + 20 >= et.y
                                && this.y + 20 <= et.y + 20) {
                            return true;
                        }
                    }
                }
            }
            break;
        }
        return b;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (true) {
            try {
                // 设置坦克休息一会
                Thread.sleep(50);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            switch (this.direct) {
            case 0:
                // 说明坦克正在向上运动（继续往上走，符合实际）
                // y -= speed;设置坦克平滑移动的效果
                for (int i = 0; i < 30; i++) {
                    if (y > 0 && !this.isTouchOtherEnemy()) {
                        y -= speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case 1:
                for (int i = 0; i < 30; i++) {
                    // 这里注意坐标起点问题不是（400x300）
                    if (x < 400 && !this.isTouchOtherEnemy()) {
                        x += speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case 2:
                for (int i = 0; i < 30; i++) {
                    if (y < 300 && !this.isTouchOtherEnemy()) {
                        y += speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case 3:
                for (int i = 0; i < 30; i++) {
                    if (x > 0 && !this.isTouchOtherEnemy()) {
                        x -= speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            }
            this.times++;
            // 设置3秒发一颗子弹
            if (times % 2 == 0) {
                if (isLive) {
                    if (ss.size() < 5) {
                        Shot s = null;
                        // 没有子弹，添加
                        switch (direct) {
                        case 0:
                            s = new Shot(x + 10, y, 0);
                            ss.add(s);
                            break;
                        case 1:
                            s = new Shot(x + 30, y + 10, 1);
                            ss.add(s);
                            break;
                        case 2:
                            s = new Shot(x + 10, y + 30, 2);
                            ss.add(s);
                            break;
                        case 3:
                            s = new Shot(x, y + 10, 3);
                            ss.add(s);
                            break;
                        }
                        // 启动子弹线程
                        Thread t = new Thread(s);
                        t.start();
                    }
                }
            }
            // 让坦克随机产生一个新的方向
            this.direct = (int) (Math.random() * 4);
            // 判断敌人坦克是否死亡了(双等号)
            if (this.isLive == false) {
                // 让坦克死亡，后退出线程
                return;
            }

        }
    }
}

// 我的坦克
class Hero1_2 extends Tank1_2 {
    // 多个子弹，用向量创建
    Vector<Shot> ss = new Vector<Shot>();
    // 子弹
    Shot s = null;

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

    // 坦克开火
    public void shotEnemy() {

        switch (this.direct) {
        case 0:
            s = new Shot(x + 10, y, 0);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 1:
            s = new Shot(x + 30, y + 10, 1);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 2:
            s = new Shot(x + 10, y + 30, 2);
            // 把子弹加入向量
            ss.add(s);
            break;

        case 3:
            s = new Shot(x, y + 10, 3);
            // 把子弹加入向量
            ss.add(s);
            break;
        }
        // 启动子弹线程（创建线程，赶紧传参，我在这里吃了大亏！）
        Thread t = new Thread(s);
        t.start();
    }

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

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

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

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

实现图片：

相关素材：

1.爆炸效果的图片（3张）

2.游戏声音素材

这个自己下载一个好啦（我的是上面命名为111.wav的文件，这里不支持上传）

原文地址：https://www.cnblogs.com/1693977889zz/p/8445905.html

时间： 2024-10-13 02:36:02

Java坦克大战（四）的相关文章

Java坦克大战（三）

关于这个坦克大战的项目是在学习Java基础的时候,拿来练习的最近看到这些代码,感觉很亲切,就把他们都复制下来,编辑成博客.回首看去,Java基础的学习确实应该建立在找项目练习上,这样才能将学到的基础知识用到实际当中,不然你知道什么是面向对象编程,什么是线程,什么是死锁,概念都了解了一大堆,等到实际应用的时候,还是力不从心.初学者千万不要灰心,真心是敲着敲着就有感觉了.下面还是循序渐进的介绍这个项目的几个版本,注释我写的很详细,新功能添加后部分代码有改动,如果感兴趣,可以看前几篇博客. 坦克大战(

Java坦克大战游戏源代码

转载自: http://blog.csdn.net/java_cxrs/article/details/3860870 经过几天的练习和研究终于自己能写出坦克大战游戏了,写完这个程序后感觉收获了很多东西,对JAVA的知识又有了一定的增长,接下来还准备继续写几个小项目来练习J2SE 由于代码太长就不发在博客里了,我上传到了资源下载里,有需要的朋友大家可以去下载 下载地址:http://download.csdn.net/source/988654

Java坦克大战（一）

接下来的几篇博客,想记录一下通过学习坦克大战项目来循序渐进的学习Java基础.主要是为了巩固基础知识,当然学习编程重要的还是多敲,问题通常是在敲代码的过程中发现的,积累也是在敲代码中寻求的经验.这个坦克大战项目是利用Java图形界面来做的,比较简陋.但是,在不断的往里面加功能的时候,可以学到很多知识,最重要的还是体会Java的面向对象编程思想.下面介绍几个用的上的Demo,最后是坦克大战的1.0版本. Demo1:回顾事件处理机制 /* * 功能:事件处理机制(ActionListener的应用

新手小项目-java坦克大战

1.界面(图形化-前端部分) 图形化用于交互,不管是用文字形式给用户选择,还是图形方式式的选择都是一种交互方式.在java中如果我们需要用到图形界面,就得想到GUI(Graphic user interface),那么我们需要用到什么,就直接去查看API(图形化显示能让我们做完项目后将结果看得舒服,而不是全部都是代码) 要做GUI,就要想到java中的AWT(abstract windows toolkit),我们写图形化都需要用到这个类库.那为什么叫抽象窗口呢?因为java是跨平台的,java

Java坦克大战游戏开发

本文介绍: 本文分为多个部分,间断性更新.主要涉及到 面向对象思想,Java GUI绘图,多线程,IO,数据库相关知识. 注:本文内容是整合了韩顺平老师的java项目(代码部分和韩顺平老师有不同)然后加上自己的一些思考写得,本文讲的有些累述,但有提示,如若基础扎实可以直接跳过,一部分面向仅仅学习了JavaSE的语法与面向对象的,一部分是面向已经掌握了GUI,多线程,IO,数据库相关知识的. 本人认为该项目可以很好地加深对面向对象思想的理解,加强对Java各个基础知识的巩固. 基本要求: 观看并且

JAVA坦克大战项目练习日4

1.java中键盘事件的getKeyCode() getKeyCode()键盘上每一个按钮都有对应码(Code),可用来查知用户按了什么键, 如[Shift]键code为16.利用getKeyCode()方法就可以得知这个码,不过读者要注意,这个方法在keyTyped() 上是无法检测出来的,因为keyTyped()只管用户输入的字符,而不会管到键盘的对应码.因此你一定要将getKeyCode()方法写keyPressed()或keyReleased()方法中才会有效,因为这两个方法是处理比较低

java坦克大战源码下载

HJZGG: http://files.cnblogs.com/files/hujunzheng/%E5%9D%A6%E5%85%8B%E5%A4%A7%E6%88%98%E6%BA%90%E7%A0%81.zip

JAVA坦克大战项目练习日3

1.如果调用repaint(),则相当于先自动调用update(),再自动调用paint()方法. 2. public abstract boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)绘制指定图像中已缩放到适合指定矩形内部的图像. 图像绘制在此图形上下文坐标空间的指定矩形内部,并且如果需要,则进行缩放.透明像素不影响该处已存在的像素. 此方法在任何情况下都立刻返回,

加强版坦克大战（java版）

转载自:http://blog.csdn.net/lihongxun945/article/details/6275581 这个坦克大战参考了初学java时看的马士兵的一个教程和小霸王上的坦克大战,并且加入了很多在魔兽中的英雄属性(移动速度,攻击速度,攻击力,生命上限等),还加入了一个小巧的地图编辑器. 废话不多说,先上图: 游戏界面: 地图编辑器: 详细说明: 1,除了坦克的图片外,其他图片全部为自己手绘,可能有点丑,特别是那个基地——! 2,游戏主界面,右边为属性窗口,在主界面按F4打开地图