坦克大战

最新推荐文章于 2023-11-05 17:57:49 发布
最新推荐文章于 2023-11-05 17:57:49 发布
阅读量260 收藏
点赞数
文章标签： 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s2251195069/article/details/78902149
版权

1.首先创建所有物体类及其所有物体定义类，在分别建立坦克类，水类，
铁，墙等障碍物类及其定义类，分别继承物体类和物体定义类，之后在
物体类和物体定义物类里添加共有属性，物体定义是用来说名物体的，
每个物体都有对应的定义属性
2.其次建立一个画板类Scene,用来画物体，同时创建一个窗口添加按钮
控制暂停，继续游戏与退出游戏，新游戏在，Scene中添加一个键盘监听，用来控制我方坦克移动和发射子弹
3.坦克移动和子弹移动的方向都就是x，y的加与减，可以用枚主类型来解决
4.总体思想是：一个线程控制所有物体的移动，画物体，一个集合将所有物体一起遍历，xml用来存每一关的障碍物。

package text.tanke;
import text.tanke.frame.MyFrame;
import text.tanke.objectscene.define.ObjectDefineHelper;

public class Start {

public static void main(String[] args) {
    ObjectDefineHelper.INSTANCE.init();
    new MyFrame();
}

}

package text.tanke.peizhi;

public class Config {
public static final int JFRAME_SIZE_X = 500;
public static final int JFRAME_SIZE_Y = 500;
public static final int SCENE_SIZE_X = 390;
public static final int SCENE_SIZE_Y = 390;
public static final int MYTANK_START_X = 120;
public static final int MYTANK_START_Y = 360;
public static final int TANK_TYPE1_YUAN_R = 10;
public static final int TANK_TYPE2_YUAN_R = 30;
public static final int DITANK_NUMBER = 4;
public static final int DITANK_START_Y = 0;
public static final int DITANK_ZHI_JIAN_JU_LI = 110;
public static final int FONT_SIZE = 25;
public static final int FONT_START_X = 100;
public static final int FONT_START_Y = 200;
public static final int OVAL_R = 10;
public static final int PAO_TONG_X = 15;
public static final int PAO_TONG_Y = 15;
public static final int PAO_TONG_CHANG_DU = 30;
public static final int GAME_ZUO_BORDER_X = 0;
public static final int GAME_YOU_BORDER_X = 360;
public static final int GAME_SHANG_BORDER_Y = 0;
public static final int GAME_XIA_BORDER_Y = 360;
public static final int ZIDAN_ZUO_BORDER_X = 0;
public static final int ZIDAN_YOU_BORDER_X = 390;
public static final int ZIDAN_SHANG_BORDER_Y = 0;
public static final int ZIDAN_XIA_BORDER_Y = 390;
public static final int DITANK_GUAI_WAN_STEEP = 30;
public static final int RUN_SLEEP_TIME = 40;
public static final int GAME_FONT_SIZE = 10;
public static final int MYGAME_ZI_START_X = 90;
public static final int DIGAME_ZI_START_X = 180;
public static final int MYGAME_LIFE_START_X = 170;
public static final int DIGAME_LIFE_START_X = 260;
public static final int LIFE_START_Y = 410;
public static final int MYTANK_START_LIFE = 3;
public static final int DITANK_START_LIFE = 30;
public static final int MAX_QIANG_NUMBER = 100;
public static final int MAX_TIE_NUMBER = 50;
public static final int MAX_WATER_NUMBER = 10;
public static final int PASS_TIME = 50;
public static final int TANKUPGRADE_FONT_SIZE = 15;
public static final int TANKUPGRADE_SIZE_WIDE = 30;
public static final int TANKUPGRADE_SIZE_HEIGHT = 30;
public static final int TANKUPGRADE_LIFE = 1;
}

package text.tanke.peizhi;
/**
*坦克，子弹方向
*/
public enum Fangxiang {
Shang(0, 0, -1), Xia(1, 0, 1), Zuo(2, -1, 0), You(3, 1, 0);

public int dirction;
public int xsudu;
public int ysudu;

Fangxiang(int dirction, int xsudu, int ysudu) {
    this.dirction = dirction;
    this.xsudu = xsudu;
    this.ysudu = ysudu;
}
/**
*用于给敌方坦克变换方向
*/
public static Fangxiang parse(int id) {
    for (Fangxiang f : values()) {
        if (f.dirction == id) {
            return f;
        }
    }
    return null;
}

}

package text.tanke.peizhi;
/**
*用于计算敌我方坦克的生命
*/
public class Life {
public static int diLife = Config.DITANK_START_LIFE;
public static int myLife = Config.MYTANK_START_LIFE;

public static int getMyLife() {
    return myLife;
}

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

public static void jianMyLife() {
    myLife--;
}

public static int getDiLife() {
    return diLife;
}

public static void setDiLife(int diLife) {
    Life.diLife = diLife;
}

public static void jianDiLife() {
    diLife--;
}

}

package text.tanke.peizhi;
/**
*所有物体的位置
*/
public class Position {
private int x;
private int y;

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

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

public int getX() {
    return x;
}

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

public int getY() {
    return y;
}

}

package text.tanke.util;

import java.util.Random;
/**
*敌方坦克每走一步多大概率改变方向
*/
public class RandomUtil {
private static final Random rand = new Random();

public static boolean randomjd(double time) {
    return rand.nextDouble() <= time;
}

}

package text.tanke.util;
/**
*睡眠时间
*/
public class SleepUtil {
public static void sleep(int time) {
try {
Thread.sleep(time);
} catch (Exception e) {
}
}
}

package text.tanke.util;
/**
*用于判别敌我方的队伍
*/
public enum TeamUtil {
MyTeam(), DiTeam(), QianTeam(), TieTeam(), JidiTeam(), Water(),;
}

package text.tanke.util;
/**
*判断物体的类别
*/
public class TypeUtil {
public static final int TANK = 1;
public static final int BULLET = 2;
public static final int TIE = 3;
public static final int QIANG = 4;
public static final int JIDI = 5;
public static final int WATER = 6;
}

package text.tanke.frame;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

import text.tanke.Scene.Scene;
import text.tanke.peizhi.Config;
import text.tanke.peizhi.Life;

public class MyFrame extends JFrame implements ActionListener {

private static final long serialVersionUID = 1L;
Scene scene = null;
JMenuBar jb = null;
JMenu cd = null;
JMenuItem cdx1 = null;
JMenuItem cdx2 = null;
JMenuItem cdx3 = null;
JMenuItem cdx4 = null;

public MyFrame() {
    scene = new Scene();
    this.add(scene);
    Thread xc = new Thread(scene);
    xc.start();
    this.addKeyListener(scene);
    jb = new JMenuBar();
    cd = new JMenu("菜单(G)");
    cd.setMnemonic('G');
    cdx1 = new JMenuItem("新游戏");
    cdx2 = new JMenuItem("退出游戏");
    cdx3 = new JMenuItem("继续游戏");
    cdx4 = new JMenuItem("暂停");
    cdx1.addActionListener(this);
    cdx1.setActionCommand("X");
    cdx2.addActionListener(this);
    cdx2.setActionCommand("T");
    cdx3.addActionListener(this);
    cdx3.setActionCommand("J");
    cdx4.addActionListener(this);
    cdx4.setActionCommand("Z");
    cd.add(cdx1);
    cd.add(cdx2);
    cd.add(cdx3);
    cd.add(cdx4);
    jb.add(cd);
    this.setJMenuBar(jb);
    this.setTitle("坦克大战");
    this.setLocation(500,140);
    this.setSize(Config.JFRAME_SIZE_X, Config.JFRAME_SIZE_Y);
    this.setVisible(true);
    this.setDefaultCloseOperation(3);
}

@Override
public void actionPerformed(ActionEvent e) {
    if (e.getActionCommand().equals("X")) {
        scene.init();//此方法是出始化
        scene.setIsmyGame(true);
        scene.setIsdiGame(true);
        Life.setDiLife(Config.DITANK_START_LIFE);
        Life.setMyLife(Config.MYTANK_START_LIFE);
        scene.pause = false;//pase暂停
    }
    if (e.getActionCommand().equals("T")) {
        System.exit(0);//退出系统
    }
    if (e.getActionCommand().equals("J")) {
        scene.pause = false;
    }
    if (e.getActionCommand().equals("Z")) {
        scene.pause = true;
    }
}

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.Vector;
import javax.swing.JPanel;

import text.tanke.objectscene.define.JidiDefine;
import text.tanke.objectscene.define.JidiDefineHelper;
import text.tanke.objectscene.define.QiangCheckpointDefine;
import text.tanke.objectscene.define.QiangDefine;
import text.tanke.objectscene.define.QiangDefineHelper;
import text.tanke.objectscene.define.TankDefine;
import text.tanke.objectscene.define.TankDefineHelper;
import text.tanke.objectscene.define.TankTypeDefine;
import text.tanke.objectscene.define.TieCheckpointDefine;
import text.tanke.objectscene.define.TieDefine;
import text.tanke.objectscene.define.TieDefineHelper;
import text.tanke.objectscene.define.WaterCheckpointDefine;
import text.tanke.objectscene.define.WaterDefine;
import text.tanke.objectscene.define.WaterDefineHelper;
import text.tanke.peizhi.Config;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Life;
import text.tanke.peizhi.Position;
import text.tanke.util.SleepUtil;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Scene extends JPanel implements Runnable, KeyListener {

private static final long serialVersionUID = 1L;
public Vector<ObjectScene> list = new Vector<ObjectScene>();
private boolean isGame = true;
public boolean pause = false;
private boolean ismyGame = true;
private boolean isdiGame = true;
private boolean ismytankMove = false;
private boolean ismytankBullet = false;
public static int gateNumber = 1;//关卡数
private int step = 0;
private Tank mytank;
private int Passtime = 1;

public void init() {
    isGame = false;
    list = new Vector<ObjectScene>();
    TankTypeDefine define = TankDefineHelper.INSTANCE.tank_define.get(4);
    TankDefine mydefine = define.level_define.get(1);
    mytank = new Tank(new Position(Config.MYTANK_START_X, Config.MYTANK_START_Y), mydefine, Fangxiang.Shang, this,
            TeamUtil.MyTeam);
    list.add(mytank);
    JidiDefine jidefine = JidiDefineHelper.INSTANCE.type_define.get(5);
    Jidi jidi = new Jidi(new Position(jidefine.startx, jidefine.starty), jidefine, Fangxiang.Shang, this);
    list.add(jidi);
    for (int i = 0; i < Config.DITANK_NUMBER; i++) {
        int ditype = (int) (Math.random() * 3 + 1);
        TankTypeDefine definedi = TankDefineHelper.INSTANCE.tank_define.get(ditype);
        TankDefine didefine = definedi.level_define.get(1);
        Tank ditank = new Tank(new Position(Config.DITANK_ZHI_JIAN_JU_LI * i, Config.DITANK_START_Y), didefine,
                Fangxiang.Xia, this, TeamUtil.DiTeam);
        list.add(ditank);
    }
    addJidiQiang();
    addObjectScene();
}

public void addJidiQiang() {
    for (int i = 1; i < Config.MAX_QIANG_NUMBER; i++) {
        QiangCheckpointDefine qiangdefine = QiangDefineHelper.INSTANCE.qiang_define.get(gateNumber);
        QiangDefine qiangdefinei = qiangdefine.id_define.get(i);
        if (qiangdefinei != null) {
            Qiang qiang = new Qiang(new Position(qiangdefinei.startx, qiangdefinei.starty), qiangdefinei,
                    Fangxiang.Shang, this);
            list.add(qiang);
        }
    }
}

public void addObjectScene() {
    for (int i = 1; i < Config.MAX_TIE_NUMBER; i++) {
        TieCheckpointDefine tiedefine = TieDefineHelper.INSTANCE.Tie_define.get(gateNumber);
        TieDefine tiedefinei = tiedefine.id_define.get(i);
        if (tiedefinei != null) {
            Tie tie = new Tie(new Position(tiedefinei.startx, tiedefinei.starty), tiedefinei, Fangxiang.Shang,
                    this);
            list.add(tie);
        }
    }
    for (int i = 0; i < Config.MAX_WATER_NUMBER; i++) {
        WaterCheckpointDefine waterdefine = WaterDefineHelper.INSTANCE.water_define.get(gateNumber);
        WaterDefine waterdefinei = waterdefine.id_define.get(i);
        if (waterdefinei != null) {
            Water water = new Water(new Position(waterdefinei.startx, waterdefinei.starty), waterdefinei,
                    Fangxiang.Shang, this);
            list.add(water);
        }
    }
}

public void paint(Graphics g) {
    super.paint(g);
    g.fillRect(0, 0, Config.SCENE_SIZE_X, Config.SCENE_SIZE_Y);
    if (isGame) {//没有新游戏之前的面板
        Font font = new Font("楷书", Font.BOLD, Config.FONT_SIZE);
        g.setFont(font);
        g.setColor(Color.RED);
        g.drawString("第零关,准备开始", Config.FONT_START_X, Config.FONT_START_Y);
    } else if (!isGame) {
        TankShuLiang(g);
        judeWinOrLose(g);
        for (int i = 0; i < list.size(); i++) {
            ObjectScene object = list.get(i);
            object.drawColor(g);
            object.drawMySelf(g);
        }
    }
}

public void judeWinOrLose(Graphics g) {
    if (!ismyGame) {
        Font font = new Font("楷书", Font.BOLD, Config.FONT_SIZE);
        g.setFont(font);
        g.setColor(Color.RED);
        g.drawString("很遗憾!你输了", Config.FONT_START_X, Config.FONT_START_Y);

    } else if (!isdiGame) {
        Font font = new Font("楷书", Font.BOLD, Config.FONT_SIZE);
        g.setFont(font);
        g.setColor(Color.RED);
        g.drawString("你赢了,进入下一关", Config.FONT_START_X, Config.FONT_START_Y);
        if (gateNumber < 2) {
            gateNumber++;
        } else if (gateNumber > 2) {
            gateNumber = 1;
        }
        pause = true;
    }
}

/**
*记录敌我双方坦克生命
*/
public void TankShuLiang(Graphics g) {
Font font = new Font(“楷书”, Font.BOLD, Config.GAME_FONT_SIZE);
g.setFont(font);
g.setColor(Color.RED);
g.drawString(“红方生命数量:”, Config.MYGAME_ZI_START_X, Config.LIFE_START_Y);
g.drawString(Life.myLife + “”, Config.MYGAME_LIFE_START_X, Config.LIFE_START_Y);
g.setColor(Color.BLUE);
g.drawString(“敌方生命数量:”, Config.DIGAME_ZI_START_X, Config.LIFE_START_Y);
g.drawString(Life.diLife + “”, Config.DIGAME_LIFE_START_X, Config.LIFE_START_Y);
}

@Override
public void run() {
    while (true) {
        passSuspend();
        while (!pause && ismyGame && isdiGame) {
            SleepUtil.sleep(Config.RUN_SLEEP_TIME);
            for (int i = 0; i < list.size(); i++) {
                step = 0;
                ObjectScene objecti = list.get(i);
                objecti.launchBullet();
                ArrayList<ObjectScene> colision = new ArrayList<ObjectScene>();
                for (int j = 0; j < list.size(); j++) {
                    ObjectScene objecctj = list.get(j);
                    if (objecti != objecctj && judecolision(objecti, objecctj)) {
                        if (objecti.type == TypeUtil.TANK && objecctj.type == TypeUtil.TANK) {
                            objecti.move();
                        }
                    }
                }
                objecti.move();
                for (int j = 0; j < list.size(); j++) {
                    ObjectScene objecctj = list.get(j);
                    if (objecti != objecctj && judecolision(objecti, objecctj)) {
                        colision.add(objecctj);
                    }
                }
                colision(objecti, colision);
                addNewTank(objecti, colision);
            }
            anJianSet();
            this.repaint();
        }
        SleepUtil.sleep(Config.RUN_SLEEP_TIME);
    }
}
/**
*通关后进入下一关的停顿时间
*/
public void passSuspend() {
    if (!isdiGame) {
        if (Passtime < Config.PASS_TIME) {
            Passtime++;
        } else if (Passtime >= Config.PASS_TIME) {
            init();
            Life.setDiLife(Config.DITANK_START_LIFE);
            setIsmyGame(true);
            setIsdiGame(true);
            Passtime = 1;
            pause = false;
        }
    }
    if (ismyGame && isdiGame) {
        anJianSet();
    }
}

/**
*判断是否碰撞
*/
public boolean judecolision(ObjectScene objecti, ObjectScene objectj) {
if (Math.abs(objecti.position.getX() + objecti.define.width / 2 - objectj.position.getX()
- objectj.define.width / 2) <= (objecti.define.width + objectj.define.width) / 2) {
if (Math.abs(objecti.position.getY() + objecti.define.height / 2 - objectj.position.getY()
- objectj.define.height / 2) <= (objecti.define.height + objectj.define.height) / 2) {
return true;
}
}
return false;
}
/**
*碰撞处理
*/
public void colision(ObjectScene objecti, ArrayList colision) {
for (ObjectScene so : colision) {
switch (objecti.type) {
case TypeUtil.TANK:
switch (so.type) {
case TypeUtil.TANK:
objecti.back();
break;
case TypeUtil.TIE:
case TypeUtil.QIANG:
case TypeUtil.WATER:
if (step == 0) {//碰到个障碍物或坦克只让退一步
objecti.back();
step++;
}
break;
case TypeUtil.BULLET:
if (objecti.team != so.team) {
objecti.life–;
so.life–;
if (objecti.life == 0) {
list.remove(objecti);
}
if (so.life == 0) {
list.remove(so);
}
}
break;
}
break;
case TypeUtil.BULLET:
if (objecti.team != so.team && so.type != TypeUtil.WATER) {
objecti.life–;
if (so.type != TypeUtil.TIE && so.type != TypeUtil.WATER) {
so.life–;
if (so.type == TypeUtil.JIDI) {
ismyGame = false;
}
}
if (objecti.life == 0) {
list.remove(objecti);
}
if (so.life == 0) {
list.remove(so);
}
}
break;
}
}
}
/**
*死一个坦克后判断是否添加新坦克
*/
public void addNewTank(ObjectScene objecti, ArrayList colision) {
for (ObjectScene so : colision) {
if (objecti.type == TypeUtil.TANK && so.type == TypeUtil.BULLET && objecti.life == 0) {
if (objecti.team == TeamUtil.MyTeam && so.team == TeamUtil.DiTeam) {
Life.jianMyLife();
if (Life.getMyLife() == 0) {
ismyGame = false;
}
if (Life.getMyLife() > 0) {
TankTypeDefine define = TankDefineHelper.INSTANCE.tank_define.get(4);
TankDefine mydefine = define.level_define.get(1);
mytank = new Tank(new Position(Config.MYTANK_START_X, Config.MYTANK_START_Y), mydefine,
Fangxiang.Shang, this, TeamUtil.MyTeam);
list.add(mytank);
}
} else if (objecti.team == TeamUtil.DiTeam && so.team == TeamUtil.MyTeam) {
Life.jianDiLife();
if (Life.getDiLife() == 0) {
isdiGame = false;
}
if (Life.getDiLife() > 3) {
int ditype = (int) (Math.random() * 3 + 1);
int i = (int) (Math.random() * 4);
TankTypeDefine definedi = TankDefineHelper.INSTANCE.tank_define.get(ditype);
TankDefine didefine = definedi.level_define.get(1);
Tank ditank = new Tank(new Position(Config.DITANK_ZHI_JIAN_JU_LI * i, Config.DITANK_START_Y),
didefine, Fangxiang.Xia, this, TeamUtil.DiTeam);
list.add(ditank);
}
}
} else if (objecti.type == TypeUtil.BULLET && so.type == TypeUtil.TANK && so.life == 0) {
if (objecti.team == TeamUtil.DiTeam && so.team == TeamUtil.MyTeam) {
Life.jianMyLife();
if (Life.getMyLife() == 0) {
ismyGame = false;
}
if (Life.getMyLife() > 0) {
TankTypeDefine define = TankDefineHelper.INSTANCE.tank_define.get(4);
TankDefine mydefine = define.level_define.get(1);
mytank = new Tank(new Position(Config.MYTANK_START_X, Config.MYTANK_START_Y), mydefine,
Fangxiang.Shang, this, TeamUtil.MyTeam);
list.add(mytank);
}
} else if (objecti.team == TeamUtil.MyTeam && so.team == TeamUtil.DiTeam) {
Life.jianDiLife();
if (Life.getDiLife() == 0) {
isdiGame = false;
}
if (Life.getDiLife() > 3) {
int ditype = (int) (Math.random() * 3 + 1);
int i = (int) (Math.random() * 4);
TankTypeDefine definedi = TankDefineHelper.INSTANCE.tank_define.get(ditype);
TankDefine didefine = definedi.level_define.get(1);
Tank ditank = new Tank(new Position(Config.DITANK_ZHI_JIAN_JU_LI * i, Config.DITANK_START_Y),
didefine, Fangxiang.Xia, this, TeamUtil.DiTeam);
list.add(ditank);
}
}
}
}
}

@Override
public void keyTyped(KeyEvent e) {

}

ArrayList<String> set = new ArrayList<>();
//根据键盘是否按下来控制集合删减
@Override
public void keyReleased(KeyEvent e) {
    set.remove(e.getKeyCode() + "");
}

@Override
public void keyPressed(KeyEvent e) {
    String str = e.getKeyCode() + "";
    if (!set.contains(str)) {
        set.add(str);
    }
}

private void anJianSet() {
    String pausex = null;
    String fangxiang = null;
    String zidan = null;
    for (String s : set) {
        switch (s) {
        case KeyEvent.VK_A + "":
        case KeyEvent.VK_W + "":
        case KeyEvent.VK_S + "":
        case KeyEvent.VK_D + "":
            fangxiang = s;
        case KeyEvent.VK_J + "":
            zidan = s;
        case KeyEvent.VK_P + "":
            pausex = s;
        }
    }
    if (zidan != null && !pause) {
        anJianZhiXin(zidan);
    }
    if (fangxiang != null && !pause) {
        anJianZhiXin(fangxiang);
    } else if (fangxiang == null) {
        ismytankMove = false;
    }
    if (pausex != null) {
        anJianZhiXin(pausex);
    }
}

/**
*在我方坦克的move中是否可以发子弹与移动，并暂停
*/
private void anJianZhiXin(String s) {
int code = Integer.parseInt(s);
switch (code) {
case KeyEvent.VK_W:
mytank.fx = Fangxiang.Shang;
ismytankMove = true;
break;
case KeyEvent.VK_S:
mytank.fx = Fangxiang.Xia;
ismytankMove = true;
break;
case KeyEvent.VK_A:
mytank.fx = Fangxiang.Zuo;
ismytankMove = true;
break;
case KeyEvent.VK_D:
mytank.fx = Fangxiang.You;
ismytankMove = true;
break;
case KeyEvent.VK_J:
ismytankBullet = true;
break;
case KeyEvent.VK_P:
pause = !pause;
}
}

public void setIsmyGame(boolean ismyGame) {
    this.ismyGame = ismyGame;
}

public void setIsdiGame(boolean isdiGame) {
    this.isdiGame = isdiGame;
}

public boolean getIsmytankMove() {
    return ismytankMove;
}

public void setIsmytankBullet(boolean ismytankBullet) {
    this.ismytankBullet = ismytankBullet;
}

public boolean getIsmytankBullet() {
    return ismytankBullet;
}

}

package text.tanke.Scene;

import java.awt.Graphics;

import text.tanke.objectscene.define.ObjectDefine;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.TeamUtil;

public abstract class ObjectScene {
protected ObjectDefine define;
protected Position position;
protected Fangxiang fx;
protected Scene scene;
protected boolean shengming = true;
protected int type;
protected int life;
protected TeamUtil team;

public ObjectScene(Position position, ObjectDefine define, Fangxiang fx, Scene scene, TeamUtil team) {
    this.position = position;
    this.define = define;
    this.fx = fx;
    this.scene = scene;
    this.team = team;
}

public abstract ObjectDefine getDefine();

public abstract void move();

public abstract void back();

public abstract void drawColor(Graphics g);

public abstract void drawMySelf(Graphics g);

public abstract void launchBullet();

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Graphics;
import text.tanke.objectscene.define.BulletDefine;
import text.tanke.objectscene.define.BulletDefineHelper;
import text.tanke.objectscene.define.TankDefine;
import text.tanke.peizhi.Config;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.RandomUtil;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Tank extends ObjectScene {

public Tank(Position position, TankDefine define, Fangxiang fx, Scene scene, TeamUtil team) {
    super(position, define, fx, scene, team);
    this.type = TypeUtil.TANK;
    this.life = define.life;
}

private int steep = 0;
private int time = 0;
Bullet bullet = null;

@Override
public void move() {
    if (getDefine().color != 4) {
        if (RandomUtil.randomjd(0.155) && steep > Config.DITANK_GUAI_WAN_STEEP) {
            int r = (int) (Math.random() * 4);
            fx = Fangxiang.parse(r);
            steep = 0;
        }
        steep++;
        moveCoordinate();
    } else if (getDefine().color == 4) {
        if (scene.getIsmytankMove()) {
            moveCoordinate();
        }
    }
}

public void moveCoordinate() {
    position.setX(position.getX() + getDefine().speed * fx.xsudu);
    if (position.getX() < Config.GAME_ZUO_BORDER_X) {
        position.setX(Config.GAME_ZUO_BORDER_X);
    }
    if (position.getX() > Config.GAME_YOU_BORDER_X) {
        position.setX(Config.GAME_YOU_BORDER_X);
    }
    position.setY(position.getY() + getDefine().speed * fx.ysudu);
    if (position.getY() < Config.GAME_SHANG_BORDER_Y) {
        position.setY(Config.GAME_SHANG_BORDER_Y);
    }
    if (position.getY() > Config.GAME_XIA_BORDER_Y) {
        position.setY(Config.GAME_XIA_BORDER_Y);
    }
}

@Override
public void drawColor(Graphics g) {
    if (getDefine().color >= 4) {
        g.setColor(Color.RED);
    } else {
        if (this.life == 1) {
            g.setColor(Color.BLUE);
        } else if (this.life == 2) {
            g.setColor(Color.WHITE);
        } else if (this.life == 3) {
            g.setColor(Color.GREEN);
        }
    }
}

@Override
public void drawMySelf(Graphics g) {
    g.drawLine(position.getX() + Config.PAO_TONG_X, position.getY() + Config.PAO_TONG_Y,
            position.getX() + Config.PAO_TONG_X + Config.PAO_TONG_CHANG_DU * fx.xsudu,
            position.getY() + Config.PAO_TONG_Y + Config.PAO_TONG_CHANG_DU * fx.ysudu);
    if (getDefine().color == 1) {
        g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
        g.fillOval(position.getX() + Config.TANK_TYPE1_YUAN_R, position.getY() + Config.TANK_TYPE1_YUAN_R,
                Config.TANK_TYPE1_YUAN_R, Config.TANK_TYPE1_YUAN_R);
    } else if (getDefine().color == 2) {
        g.fillOval(position.getX(), position.getY(), Config.TANK_TYPE2_YUAN_R, Config.TANK_TYPE2_YUAN_R);
    } else if (getDefine().color == 3) {
        g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
        g.fillRect(position.getX() + getDefine().width / 6, position.getY() + getDefine().height / 6,
                getDefine().width * 2 / 3, getDefine().height * 2 / 3);
    } else if (getDefine().color == 4) {
        if (getDefine().level == 1) {
            g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
            g.fillOval(position.getX() + Config.TANK_TYPE1_YUAN_R, position.getY() + Config.TANK_TYPE1_YUAN_R,
                    Config.TANK_TYPE1_YUAN_R, Config.TANK_TYPE1_YUAN_R);
        } else if (getDefine().level == 2) {
            g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
            g.fillRect(position.getX() + getDefine().width / 3, position.getY() + getDefine().height / 3,
                    getDefine().width / 3, getDefine().height / 3);
        } else if (getDefine().level == 3) {
            g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
            g.fillRect(position.getX() + getDefine().width / 3, position.getY() + getDefine().height / 3,
                    getDefine().width / 3, getDefine().height / 3);
            g.drawOval(position.getX(), position.getY(), getDefine().width, getDefine().height);
        }
    }
}

@Override
public void launchBullet() {
    if (getDefine().color < 4) {
        time++;
        if (time >= 45) {
            time = 0;
            BulletDefine bulletdefine = BulletDefineHelper.INSTANCE.type_define.get(1);
            bullet = new Bullet(
                    new Position(position.getX() + getDefine().width / 2, position.getY() + getDefine().height / 2),
                    bulletdefine, fx, scene, TeamUtil.DiTeam);
            scene.list.add(bullet);
        }
    } else {
        if (scene.getIsmytankBullet()) {
            if (bullet == null || !bullet.shengming || bullet.life <= 0) {
                BulletDefine bulletdefine = BulletDefineHelper.INSTANCE.type_define.get(1);
                bullet = new Bullet(
                        new Position(position.getX() + getDefine().width / 2,
                                position.getY() + getDefine().height / 2),
                        bulletdefine, fx, scene, TeamUtil.MyTeam);
                scene.list.add(bullet);
            }
        }
        scene.setIsmytankBullet(false);
    }
}

@Override
public void back() {
    position.setX(position.getX() - getDefine().speed * fx.xsudu);
    if (position.getX() < Config.GAME_ZUO_BORDER_X) {
        position.setX(Config.GAME_ZUO_BORDER_X);
    }
    if (position.getX() > Config.GAME_YOU_BORDER_X) {
        position.setX(Config.GAME_YOU_BORDER_X);
    }
    position.setY(position.getY() - getDefine().speed * fx.ysudu);
    if (position.getY() < Config.GAME_SHANG_BORDER_Y) {
        position.setY(Config.GAME_SHANG_BORDER_Y);
    }
    if (position.getY() > Config.GAME_XIA_BORDER_Y) {
        position.setY(Config.GAME_XIA_BORDER_Y);
    }
}

@Override
public TankDefine getDefine() {
    return (TankDefine) define;
}

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Graphics;

import text.tanke.objectscene.define.BulletDefine;
import text.tanke.peizhi.Config;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Bullet extends ObjectScene {

public Bullet(Position position, BulletDefine define, Fangxiang fx, Scene scene, TeamUtil team) {
    super(position, define, fx, scene, team);
    this.type = TypeUtil.BULLET;
    this.life = define.life;
}

@Override
public void move() {
    position.setX(position.getX() + getDefine().speed * fx.xsudu);
    position.setY(position.getY() + getDefine().speed * fx.ysudu);
    if (position.getX() < Config.ZIDAN_ZUO_BORDER_X || position.getX() > Config.ZIDAN_YOU_BORDER_X
            || position.getY() < Config.ZIDAN_SHANG_BORDER_Y || position.getY() > Config.ZIDAN_XIA_BORDER_Y) {
        shengming = false;
    }
}

@Override
public void drawColor(Graphics g) {
    g.setColor(Color.WHITE);
}

@Override
public void drawMySelf(Graphics g) {
    if (getDefine().type == 1) {
        g.fillRect(position.getX(), position.getY(), getDefine().height, getDefine().width);
    } else if (getDefine().type == 2) {
        g.fillOval(position.getX(), position.getY(), getDefine().height, getDefine().width);
    } else if (getDefine().type == 3) {
        g.drawRect(position.getX(), position.getY(), getDefine().height, getDefine().width);
        g.fillOval(position.getX(), position.getY(), getDefine().height, getDefine().width);
    }
}

@Override
public void back() {

}

@Override
public BulletDefine getDefine() {
    return (BulletDefine) define;
}

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

}

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Graphics;

import text.tanke.objectscene.define.QiangDefine;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Qiang extends ObjectScene {

public Qiang(Position position, QiangDefine define, Fangxiang fx, Scene scene) {
    super(position, define, fx, scene, TeamUtil.QianTeam);
    this.type = TypeUtil.QIANG;
    this.life = getDefine().life;
}

@Override
public void drawColor(Graphics g) {
    g.setColor(Color.RED);
}

@Override
public void drawMySelf(Graphics g) {
    g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
}

@Override
public QiangDefine getDefine() {
    return (QiangDefine) define;
}

@Override
public void move() {

}

@Override
public void back() {

}

@Override
public void launchBullet() {

}

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Graphics;

import text.tanke.objectscene.define.TieDefine;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Tie extends ObjectScene {

public Tie(Position position, TieDefine define, Fangxiang fx, Scene scene) {
    super(position, define, fx, scene, TeamUtil.TieTeam);
    this.type = TypeUtil.TIE;
    this.life = getDefine().life;
}

@Override
public void drawColor(Graphics g) {
    g.setColor(Color.WHITE);
}

@Override
public void drawMySelf(Graphics g) {
    g.drawRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
}

@Override
public TieDefine getDefine() {
    return (TieDefine) define;
}

@Override
public void move() {

}

@Override
public void back() {

}

@Override
public void launchBullet() {

}

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Graphics;

import text.tanke.objectscene.define.JidiDefine;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Jidi extends ObjectScene {

public Jidi(Position position, JidiDefine define, Fangxiang fx, Scene scene) {
    super(position, define, fx, scene, TeamUtil.JidiTeam);
    this.type = TypeUtil.JIDI;
    this.life = getDefine().life;
}

@Override
public void drawColor(Graphics g) {
    g.setColor(Color.BLACK);
}

@Override
public void drawMySelf(Graphics g) {
    g.fillRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
}

@Override
public JidiDefine getDefine() {
    return (JidiDefine) define;
}

@Override
public void move() {

}

@Override
public void back() {

}

@Override
public void launchBullet() {

}

}

package text.tanke.Scene;

import java.awt.Color;
import java.awt.Graphics;

import text.tanke.objectscene.define.WaterDefine;
import text.tanke.peizhi.Fangxiang;
import text.tanke.peizhi.Position;
import text.tanke.util.TeamUtil;
import text.tanke.util.TypeUtil;

public class Water extends ObjectScene {

public Water(Position position, WaterDefine define, Fangxiang fx, Scene scene) {
    super(position, define, fx, scene, TeamUtil.Water);
    this.type = TypeUtil.WATER;
    this.life = getDefine().life;
}

@Override
public void drawColor(Graphics g) {
    g.setColor(Color.BLUE);
}

@Override
public void drawMySelf(Graphics g) {
    g.fillRect(position.getX(), position.getY(), getDefine().width, getDefine().height);
}

@Override
public WaterDefine getDefine() {
    return (WaterDefine) define;
}

@Override
public void move() {

}

@Override
public void back() {

}

@Override
public void launchBullet() {

}

}

package text.tanke.util;

import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

/**
*读取xml的基本工具
*/
public class XmlReader {

public static Element getRootElement(String path) {
    try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();// 获取生成 DOM 对象树的解析器
        DocumentBuilder docBuilder = factory.newDocumentBuilder();
        // 应用程序员可以从 XML 获取一个 Document
        Document doc = docBuilder.parse(path);// 将给定文件的内容解析为一个 XML 文档，并且返回一个新的 DOM Document
        doc.normalize();
        NodeList nodeList = doc.getElementsByTagName("config");// 按文档顺序返回包含在文档中且具有给定标记名称的所有 Element 的 NodeList
        return (Element) nodeList.item(0);// 返回集合中的第 index 个项
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static ArrayList<Element> parseElements(Element root, String tagName) {
    NodeList nodeList = root.getElementsByTagName(tagName);
    ArrayList<Element> list = new ArrayList<>();
    for (int i = 0; i < nodeList.getLength(); i++) {
        list.add((Element) nodeList.item(i));
    }
    return list;
}

public static Element parseElement(Element root, String tagName) {
    NodeList nodeList = root.getElementsByTagName(tagName);
    return (Element) nodeList.item(0);
}

}

package text.tanke.objectscene.define;

public class ObjectDefine {

public int life;
public final int width;
public final int height;

public ObjectDefine(int life, int width, int height) {
    this.life = life;
    this.width = width;
    this.height = height;
}

}

package text.tanke.objectscene.define;

import org.w3c.dom.Element;

import text.tanke.util.XmlReader;

public class ObjectDefineHelper {
public static final ObjectDefineHelper INSTANCE = new ObjectDefineHelper();

private ObjectDefineHelper() {
}

public void init() {
    String path = System.getProperty("user.dir");
    Element root = XmlReader.getRootElement(path + "/config/define.xml");
    TankDefineHelper.INSTANCE.init(root);
    BulletDefineHelper.INSTANCE.init(root);
    TieDefineHelper.INSTANCE.init(root);
    QiangDefineHelper.INSTANCE.init(root);
    JidiDefineHelper.INSTANCE.init(root);
    WaterDefineHelper.INSTANCE.init(root);
}

}

package text.tanke.util;

import java.util.ArrayList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

public class XmlReader {

public static Element getRootElement(String path) {
    try {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = factory.newDocumentBuilder();

        Document doc = docBuilder.parse(path);
        doc.normalize();
        NodeList nodeList = doc.getElementsByTagName("config"); 
        return (Element) nodeList.item(0);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public static ArrayList<Element> parseElements(Element root, String tagName) {
    NodeList nodeList = root.getElementsByTagName(tagName);
    ArrayList<Element> list = new ArrayList<>();
    for (int i = 0; i < nodeList.getLength(); i++) {
        list.add((Element) nodeList.item(i));
    }
    return list;
}

public static Element parseElement(Element root, String tagName) {
    NodeList nodeList = root.getElementsByTagName(tagName);
    return (Element) nodeList.item(0);
}

}

package text.tanke.objectscene.define;

import org.w3c.dom.Element;

public class BulletDefine extends ObjectDefine {
public final int speed;
public final int type;

public BulletDefine(int life, int width, int height, int speed, int type) {
    super(life, width, height);
    this.speed = speed;
    this.type = type;
}

public static BulletDefine init(Element root) {
    int life = Integer.parseInt(root.getAttribute("life"));
    int width = Integer.parseInt(root.getAttribute("width"));
    int height = Integer.parseInt(root.getAttribute("height"));
    int sudu = Integer.parseInt(root.getAttribute("speed"));
    int type = Integer.parseInt(root.getAttribute("type"));
    return new BulletDefine(life, width, height, sudu, type);
}

}

package text.tanke.objectscene.define;

import java.util.ArrayList;
import java.util.HashMap;

import org.w3c.dom.Element;

import text.tanke.util.XmlReader;

public class BulletDefineHelper {
public static final BulletDefineHelper INSTANCE = new BulletDefineHelper();
public final HashMap

黄材牛哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
坦克大战初步框架
sunyusong666的博客
05-14 116
坦克大战初步框架
坦克大作战
Make Excellence a Habit
08-02 1008
首先我们来看一下目录: 我来解释一下 它就是原生的js写的 所有它只需要两个js文件 然后一些图片 还有一个神器的地方就是还有音频 大家可以试一下 然后还有一个index页面 图片我们放在与页面同目录下： 然后接下来我们看一下我们的js文件：（main.js） window.addEventListener("load", canvasApp, false); //是否支持canvas fu...
【Java学习笔记】62 - 坦克大战1.2，我方发射子弹（可存在多个）
qq_41891655的博客
11-05 462
完善坦克大战，加入发射子弹（子弹可以存在多个），绘出子弹
C++游戏开发——坦克大战
小木鱼的博客
05-20 3574
坦克大战
坦克大战设计与实现
qq_61141142的博客
09-16 774
摘 要 J2SE是近年来随着各种不同技术的发展，尤其是编程语言飞速发展而诞生的一项新的开发语言。随着信息技术的飞速发展，计算机的使用也日渐普及，本文从实际应用出发，向大家介绍坦克大战游戏的设计与实现。Eclipse平台模拟器开发调试。玩家坦克的运行是通过键盘响应事件控制，敌方坦克则是自动运行并具有了一定的智能性。程序进行了精简和优化，游戏运行流畅，具有一定的吸引力。 论文中介绍了游戏的总体设计思路和开发游戏的多线程、高级、低级图形界面的使用。本论文介绍了坦克大战的历史、java的相关技术及本程序的
c++编写坦克大战（同年回忆）全网最全的讲解
m0_72703340的博客
08-03 594
需要熟练的掌握c语言，c++。熟练掌握各种数据类型和数据结构。拥有优秀的文档阅读能力（设计EasyX图形库的使用），拥有一个漂亮温柔的女朋友。
坦克大战--chapter01
Jay_Wolf的博客
03-23 194
JavaScript项目 1. 生成画布 <canvas id="canvas" width="500" height="500" style="background: greenyellow"></canvas>  看起来和  标签一样，只是  只有两个可选的属性 width、heigth 属性，而没有...
C++ 控制台版本坦克大战游戏
最新发布
05-31
C++ 控制台版坦克大战游戏简介 内容概要 C++ 控制台版坦克大战游戏是一款基于C++编程语言开发的经典射击游戏。 通过键盘控制坦克移动攻击，躲避敌方坦克的攻击，同时消灭它们以完成关卡任务，支持地图编辑。 适用...
SCRATCH版坦克大战
11-09
用SCRATCH开发的坦克大战游戏，复刻童年经典，带有地图编辑器功能，可自由设计地图
Python坦克大战源代码坦克大战.zip
12-29
【Python坦克大战源代码坦克大战.zip】是一个包含Python语言实现的坦克大战小游戏的源代码集合。这个项目旨在提供一个互动的、基于文本的娱乐体验，让玩家能够享受经典的坦克战斗游戏，同时学习和理解Python编程的...
坦克大战.zip
06-13
有关python的小，用的python的pygame模块，编写的我们小时候玩的经典——坦克大战。
坦克大战完整源代码
06-25
无需配置环境，下载可用，VC6.0编译环境，完整实现fc蓝白机坦克大战的完整源代码。
坦克大战3.0
12-05
坦克大战3.0JAVA源码完整度还不错，网上找的，要的下吧····
基于Java的坦克大战游戏（含代码和报告）
07-28
基于Java的坦克大战游戏（含代码和报告）
基于FPGA实现坦克大战游戏 basy3
07-04
本设计是基于Xilinx Basys3的坦克大战游戏，通过Basys3板卡控制“坦克”的移动和射击，由拨码开关控制游戏的开始、模式选择等。游戏分为经典模式和无尽模式，经典模式中有4辆“敌方坦克”追击“己方坦克”，被击中后...
Python pygame 坦克大战源码以及图片材料等资源
06-25
【Python Pygame坦克大战源码解析】 Python Pygame是一个强大的游戏开发库，它基于Python语言，使得游戏开发变得更加简单易学。"坦克大战"是一款经典的双人对战游戏，通过Python Pygame我们可以重新构建这个游戏，...
用C语言写坦克大战
shihy_的博客
07-31 7123
今天，我们来用C语言写一个坦克大战小游戏。 首先，上代码。 #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <windows.h> #include <time.h> #include <string.h> HANDLE hout; char zt; int yz,xz,ht,wz,fen,jb; int ...
Java实现坦克大战游戏
"Java坦克大战是一款使用Java编程语言编写的坦克战斗游戏，代码包含三个.java文件。游戏界面基于Swing库构建，具有菜单栏、游戏控制功能，如新游戏、暂停和继续等操作。" 在Java坦克大战这款游戏中，开发者使用了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值