TankGame坦克大战1.0版本

最新推荐文章于 2022-05-17 20:46:48 发布
最新推荐文章于 2022-05-17 20:46:48 发布
阅读量254 收藏 2
点赞数
分类专栏： java 文章标签： 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_37765046/article/details/79067890
版权

MainFrame


package myFrame;

public class Game {

    public static void main(String[] args) {
        MyFrame mf = new MyFrame();
        mf.addListener();
    }

}

Shot（子弹类）


class Shot implements Runnable{
    int x;
    int y;
    int direct;
    int speed=3;
    //是否活着
    boolean isLive = true;
    public Shot(int x,int y,int direct){
        this.x=x;
        this.y=y;
        this.direct=direct;
    }
    @Override
    public void run() {

        while(true){

            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            switch(direct){
            case 0:
                y-=speed;break;
            case 1:
                x+=speed;break;
            case 2:
                y+=speed;break;
            case 3:
                x-=speed;break;
            }
            //子弹何时死亡：碰到边框或者敌人坦克
            if(x<0||x>400||y<0||y>300){
                this.isLive=false;
                break;
            }
        }
    }
}

Tank（坦克类）


//把敌人的坦克做成线程类
class Tank {
    //坦克的横坐标
    int x=0;
    int y=0;
    //0上 1右 2下  3左 
    int direct=0;
    int speed=5;
    int color;
    boolean isLive=true;
    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 Tank(int x,int y){
        this.x=x;
        this.y=y;

    }
}

Enemy类（敌军类）


class EnemyTank extends Tank implements Runnable{


    int times=0;
    Vector<EnemyTank> ets=new Vector<EnemyTank>();
    Vector<Shot> ss = new Vector<Shot>();

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


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

    public void setEts(Vector<EnemyTank> vv){
        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>=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+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>=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+20>=et.y && this.y+20<=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() {

        while(true){

            switch(this.direct){
            case 0:
                for(int i=0;i<30;i++){
                    if(y>5&&!this.isTouchOtherEnemy()){
                    y-=speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();    
                    }
                }
                break;
            case 1:
                for(int i=0;i<30;i++){
                    if(x<350&&!this.isTouchOtherEnemy()){
                    x+=speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();    
                    }
                }
                break;
            case 2:
                for(int i=0;i<30;i++){
                    if(y<230&&!this.isTouchOtherEnemy()){
                    y+=speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();    
                    }
                }
                break;
            case 3:
                for(int i=0;i<30;i++){
                    if(x>5&&!this.isTouchOtherEnemy()){
                    x-=speed;
                    }
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();    
                    }
                }
                break;
            }



            //让坦克随机产生一个新的方向
            this.direct=(int)(Math.random()*4); 
            //判断敌人坦克是否死亡
            if(this.isLive==false){
                break;
            }
            this.times++;

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

Hero类（本机类）


class Hero extends Tank
{

        //子弹

        //Shot s=null;
        Vector<Shot> ss=new Vector<Shot>();

        Shot s=null;
        public Hero(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;
        }
    }

音乐播放类


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{ //恢复记录点
    public Node(int x, int y, int direct) {
        this.x=x;
        this.y=y;
        this.direct=direct;
    }
    int x;
    int y;
    int direct;
}

记录节点类


class Recorder{

    private static int enNum=20;
    private static int myLisfe=3;
    private static int allEnNum=0;

    //从文件中恢复记录点
        /*private*/ 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 static Vector<EnemyTank> ets=new Vector<EnemyTank>();

        public Vector<Node> getNodesAndEnNums()
        {
            try {
                fr=new FileReader("f:\\myRecording.txt");
                br=new BufferedReader(fr);
                String n="";

                //先读取第一行
                n=br.readLine();
                allEnNum=Integer.parseInt(n);

                while((n=br.readLine())!=null)
                {
                    String []x=n.split(" "); 
                    Node node=new Node(Integer.parseInt(x[0]),Integer.parseInt(x[1]),Integer.parseInt(x[2]));
                    nodes.add(node);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                try{
                    //后打开则先关闭
                    br.close();
                    fr.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            return nodes;

        }

        public static void keepRecAndEnemyTank()
        {
            try {
                //创建
                fw=new FileWriter("f:\\myRecording.txt");
                bw=new BufferedWriter(fw);

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

                System.out.println("size="+ets.size());
                //保存当前活的敌人坦克的坐标和方向
                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 (Exception e) {
                e.printStackTrace();
            }finally{

                //关闭流
                try {
                    //后开先关闭
                    bw.close();
                    fw.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        public static void getRecoring()
         {
           try {
            fr=new FileReader("f:\\myRecording.txt");
            br=new BufferedReader(fr);
            String n=br.readLine();
            allEnNum=Integer.parseInt(n);
           } catch (Exception e) {
            e.printStackTrace();
           }finally{
            try {
             br.close();
             fr.close();
            } catch (Exception e) {
             e.printStackTrace();
            }
           }
          }

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

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

            } catch (Exception e) {
                e.printStackTrace();
            }finally{

                //关闭流
                try {
                    //后开先关闭
                    bw.close();
                    fw.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }


        public static Vector<Node> getNodes() {
            return nodes;
        }


        public static void setNodes(Vector<Node> nodes) {
            Recorder.nodes = nodes;
        }


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

        public static  void setEts(Vector<EnemyTank> ets) {
            Recorder.ets = ets;//
        }

    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 getMyLisfe() {
        return myLisfe;
    }
    public static void setMyLisfe(int myLisfe) {
        Recorder.myLisfe = myLisfe;
    }

    public static void reduceEnNum(){
        enNum--;
    }
    public static void reduceMylife(){
        myLisfe--;
    }

    public static void addEnNumRec(){
        allEnNum++;
    }
}

炸弹类


class Bomb{

    int x,y;
    int life=16; 
    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;
        }
    }
}
RoniZeng
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TankGame
02-23
一个java游戏 （实验版本）
TankGame1.opensdf
08-31
基于C++的坦克大战部分代码
TankGame1.0
AnalogElectronic的博客
10-29 273
基本思想是利用多线程，画板是多线程每100ms更新一次 子弹是一个多线程50ms更新一次 坦克是一个多线程50ms更新一次 自己的坦克的方向变换是根据键盘监听响应的，速度可以设置。 敌人的坦克的方向变换是每个一定时间随机变换的，在其run函数中实现 每个坦克有一个子弹，是一一对应关系， 还有一些基本的判断，敌人坦克碰到墙壁必须超反方向运动， 我的子弹碰到敌人坦克，敌人坦克就消失，加分 敌人的坦...
【Java】坦克大战 Tank Games
xiyang_DING
05-17 808
用Java写一个坦克大战，附源代码+素材包
tank_坦克大战_
10-04
《坦克大战》是一款深受玩家喜爱的经典游戏，它承载着许多人童年的美好回忆。在这个项目中，我们将探讨如何实现这样一个激动人心的游戏。 首先，我们要理解游戏的基本机制。坦克大战的核心是两个或更多的坦克在战场...
坦克大战1.1.0版本
08-03
《坦克大战1.1.0版本》是一款基于经典游戏坦克大战的升级版，它在原有的基础上进行了诸多功能的拓展和优化。在这个版本中，开发者针对玩家体验做了深度改进，引入了摇杆控制、血条显示以及小地图等关键功能，大大...
坦克大战tank.zip
06-14
坦克大战tank：很古老却又经典的一款小游戏，完全基于python开发，我将其打包生成exe文件，感兴趣的可以拿去玩哈。 相应的博客介绍在这里：https://blog.csdn.net/Together_CZ
Tank_游戏_坦克大战_
10-03
《坦克大战》是一款深受儿童喜爱的经典游戏，它承载着无数人的童年记忆。在这个游戏中，玩家控制一辆坦克在复杂的地形中与敌方坦克进行战斗，目标是保护基地并消灭所有敌人。游戏以其简单易上手的操作、丰富的关卡...
Java坦克大战1.0版源代码
12-05
在Java编程语言中，"Java坦克大战1.0版源代码"是一个实现经典坦克游戏的项目。这个项目可能包括游戏的各个组件，如游戏逻辑、用户界面、游戏对象（如坦克、子弹、障碍物）以及游戏状态管理。下面将详细讨论其中涉及...
TankGame.unitypackage_坦克RPG项目
08-05
游戏源码,代码仅供参考，请勿商业使用，如有侵权，请及时告知
TankGame_final(最终版)上半部分
05-06
CSDN不厚道,代码积分给那么少,我只能拆分成两部分,此代码为Java版坦克大战源代码上半部分. 源代码介绍: 此代码为完整版代码,可单机游戏,包括游戏和声音,解决了网上关于Java开发坦克大战的BUG,比如第一次击中敌人不显示爆炸效果的问题,使用双缓存解决闪屏问题.
TankGame:基于 Slick2D 的自上而下的坦克射击游戏
06-28
坦克游戏 这是一个使用 Slick2D 编写的用于图形显示的自上而下的 Tank Shooter。
tank game游戏
11-08
学习了游戏编程，写了一些简单的程序，这个是坦克的源码
Tank Game bug
nuptxiaoli
08-22 379
public boolean isTouchOtherEnemy() { boolean b = false; for (int i = 0; i < ets.size(); i++) { EnemyTank tank = ets.get(i); if (tank != this) { if (this.x >= tank.x && this.x = tank.y &
tankgame网络版开发
asdhls的博客
02-11 542
序言 一个普通的tankgame单机开发，网络版开发的记录。单机开发过程后续有机会再补，本文是记录单机游戏到netty网络版开发过程踩坑的记录。 以下是过程学习的内容 1、awt图形设计（仅作了解，开发了几个窗口观察服务端和客户端日志） 2、javaSE基础知识 3、二十三种设计模式学习 4、netty聊天小程序开发 5、idea普通项目转换成maven项目踩坑记录 6、netty网络版tank 开发环境 jdk1.8_2121 idea netty4.1.73.Final
Java实现坦克大战小游戏
AnalogElectronic的博客
03-22 7726
Java实现坦克大战小游戏 MyTankGame3.java Members.java MyTankGame3.java /** * 功能:坦克游戏的5.0[] * 1.画出坦克. * 2.我的坦克可以上下左右移动 * 3.可以发射子弹,子弹连发(最多5) * 4.当我的坦克击中敌人坦克时，敌人就消失(爆炸的效果) * 5.我被击中后，显示爆炸效果 * 6.防止敌人坦克重叠...
Java valueOf() 方法
Roni
11-23 8028
语法 static Integer valueOf(int i) static Integer valueOf(String s) static Integer valueOf(String s, int radix) 参数 i-integer对象的整数 s-integer对象的字符串 radix-在解析字符串s时使用的基数，用于指定使用的进制数。 返回值 Integer value
Java坦克大战1.0源码解析
` 是Java源代码的组织单位，这里定义了一个名为`TankGame`的包，通常用于存放与坦克大战游戏相关的所有类。 2. **注释**：使用`/*...*/`和`/**...*/`的注释方式提供了关于程序和作者的基本信息，这是Java中的多行和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值