在此小易將坦克大戰(zhàn)這個(gè)項(xiàng)目分為幾個(gè)版本，以此對(duì)J2SE的知識(shí)進(jìn)行回顧和總結(jié)，希望這樣也能給剛學(xué)完J2SE的小伙伴們一點(diǎn)啟示！

(此版本基本上就可以和電腦對(duì)打了，不信把源碼放到你的電腦上就可以馬上開啟坦克大戰(zhàn)之旅哦)

坦克大戰(zhàn)V0.5實(shí)現(xiàn)功能：

1、產(chǎn)生一個(gè)敵方坦克

2、將敵人坦克擊斃，相應(yīng)的子彈和坦克都消失

3、添加爆炸效果

4、添加多輛坦克，并能夠打掉敵方坦克

5、讓敵方坦克可以隨機(jī)運(yùn)動(dòng)，可以打出子彈打掉我方坦克

6、加兩堵墻出來(lái)，可以吞沒(méi)子彈，擋住敵方坦克

7、敵方坦克相撞不能穿透過(guò)去

注意事項(xiàng)：

1、畫一輛敵人的坦克，步驟：加入?yún)^(qū)別敵我的量good，根據(jù)敵我的不同設(shè)置不同的顏色更新Tank的構(gòu)造函數(shù)，加入good，TankClient中new 出敵人的坦克并畫出(注意如果新增加了成員變量，就要馬上考慮是否要更改或新增構(gòu)造方法)

2、將敵人坦克擊斃，分析：一顆子彈擊中敵人坦克，步驟：Missle中加入hitTank(Tank)方法，返回布爾類型；利用碰撞檢測(cè)的輔助類Rectangle；為Tank和Missle都加入getRect方法；當(dāng)擊中敵人坦克時(shí)，坦克被打死，子彈也死去；增加控制Tank生死的量live，如果死去就不畫了

3、加入爆炸，步驟：添加爆炸類；用不同直徑的圓模擬爆炸；加入live；加入位置屬性；加入draw方法。爆炸應(yīng)該存在于集合類中；TankClient加入集合；將集合中的爆炸逐一畫出(如果死去就去除)。擊斃一輛坦克后應(yīng)產(chǎn)生爆炸；hitTank時(shí)應(yīng)產(chǎn)生爆炸

4、添加多輛坦克，步驟：用容器來(lái)裝敵人的Tank；向容器中裝入多輛敵人Tank；畫出來(lái)；運(yùn)行，不能打掉；添加hitTanks方法，打一系列Tank；TankClient里面每發(fā)子彈都打tanks

5、讓敵軍坦克更加智能，步驟：

==>讓敵軍坦克動(dòng)起來(lái)：構(gòu)造函數(shù)中可以指定方向；new敵軍坦克的時(shí)候指定敵軍坦克的方向。

==>讓敵軍坦克向隨機(jī)方向移動(dòng)：(Tank)靜態(tài)的，添加隨機(jī)數(shù)產(chǎn)生器 java.util.Random；move完成后，如果是敵軍坦克的，隨機(jī)產(chǎn)生一個(gè)數(shù)，來(lái)設(shè)定坦克下一個(gè)方向；Direction.values()。

==>讓敵軍坦克向隨機(jī)方向移動(dòng)隨機(jī)的步驟：添加變量，記錄隨機(jī)步驟；當(dāng)==0時(shí)，改變方向，否則，只是隨機(jī)步驟遞減；

==>讓敵軍坦克發(fā)射炮彈：本軍炮彈不打本軍；炮彈添加好壞bGood，根據(jù)好壞畫不同顏色；修改炮彈的構(gòu)造方法；修改Tank的fire方法；修改hitTank方法，好不能打好，壞不能打壞

6、添加兩堵墻，步驟：建Wall類、建立Wall對(duì)象、畫出來(lái)。

==>讓每一顆子彈打擊每一堵墻：hitWall()方法；注意子彈速度不能太快，否則很容易穿過(guò)墻；

==>讓坦克不能穿過(guò)墻：記錄上一次的位置oldX, oldY；修改構(gòu)造函數(shù)；每次move之前紀(jì)錄上一次位置；添加stay方法；記錄移動(dòng)前的位置；當(dāng)撞到時(shí)回到移動(dòng)前的位置；當(dāng)碰到墻的時(shí)候stay

坦克大戰(zhàn)V0.5源代碼：

TankClient類：

import java.awt.*;

import java.awt.event.*;

import java.util.List; //java.awt包中也有個(gè)List，所以此處要導(dǎo)包明確

import java.util.ArrayList;

public class TankClient extends Frame {

public static final int GAME_WIDTH = 800;

public static final int GAME_HEIGHT = 600;

Tank myTank = new Tank(350, 450, true, Tank.Direction.STOP, this); //我方坦克

Wall w1 = new Wall(100, 300, 20, 100, this), w2 = new Wall(300, 250, 150, 20, this);

List missiles = new ArrayList(); //定義一個(gè)集合來(lái)裝子彈

List explodes = new ArrayList();

List tanks = new ArrayList();

Image offScreenImage = null; //定義一個(gè)屏幕后的虛擬圖片

@Override

public void paint(Graphics g) {

g.drawString("missiles Count: " + missiles.size(), 10, 50); //用來(lái)記錄missiles中子彈的個(gè)數(shù)

g.drawString("explodes Count: " + explodes.size(), 10, 70);

g.drawString("tanks Count: " + tanks.size(), 10, 90);

for (int i = 0; i < missiles.size(); i++) { //遍歷集合，把其中的子彈畫出來(lái)

Missile m = missiles.get(i);

m.hitTanks(tanks);

m.hitTank(myTank);

m.hitWall(w1); //檢測(cè)子彈是否撞墻

m.hitWall(w2);

m.drawMissile(g);

}

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

Explode e = explodes.get(i);

e.draw(g);

}

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

Tank t = tanks.get(i);

t.collidesWithWall(w1); //檢測(cè)敵方坦克是否撞墻

t.collidesWithWall(w2);

t.collidesWithTanks(tanks);

t.drawTank(g);

}

myTank.drawTank(g);

w1.draw(g);

w2.draw(g);

}

//利用雙緩沖消除圓圈移動(dòng)時(shí)屏幕的閃動(dòng)

@Override

public void update(Graphics g) {

if (offScreenImage == null) {

offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT); //判斷是為了避免每次重畫時(shí)都給offScreenImage賦值

}

Graphics gOffScreen = offScreenImage.getGraphics(); //定義虛擬圖片上的畫筆gOffScreen

Color c = gOffScreen.getColor();

gOffScreen.setColor(Color.GREEN);

gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT); //重畫背景，如果沒(méi)有這句則在屏幕上會(huì)保留圓圈的移動(dòng)路徑

gOffScreen.setColor(c);

paint(gOffScreen); //把圓圈畫到虛擬圖片上

g.drawImage(offScreenImage, 0, 0, null); //再一次性把虛擬圖片畫到真實(shí)屏幕上，在真實(shí)屏幕上畫則要用真實(shí)屏幕的畫筆g

}

public void luanchFrame() {

for(int i = 0; i < 10; i++) {

tanks.add(new Tank(50 + 40*(i+1), 50, false,Tank.Direction.D, this));

}

this.setLocation(300, 50);

this.setSize(GAME_WIDTH, GAME_HEIGHT);

this.setTitle("坦克大戰(zhàn) - By:小易 - QQ：381740148");

this.setResizable(false); //不允許改變窗口大小

this.addWindowListener(new WindowAdapter() {

@Override

public void windowClosing(WindowEvent e) {

System.exit(0);

}

}); //添加關(guān)閉功能，此處使用匿名類比較合適

this.setBackground(Color.GREEN);

this.addKeyListener(new KeyMonitor());

setVisible(true);

new Thread(new PaintThread()).start(); //啟動(dòng)線程，實(shí)例化線程對(duì)象時(shí)不要忘了new Thread(Runnable對(duì)象);

}

public static void main(String[] args) {

TankClient tc = new TankClient();

tc.luanchFrame();

}

//PaintThread只為TankClient服務(wù)，所以寫成內(nèi)部類好些

public class PaintThread implements Runnable {

public void run() {

while (true) {

repaint(); //repaint()是TankClient或者他的父類的方法，內(nèi)部類可以訪問(wèn)外部包裝類的成員，這也是內(nèi)部類的好處

try {

Thread.sleep(50); //每隔50毫秒重畫一次

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

public class KeyMonitor extends KeyAdapter {

@Override

public void keyReleased(KeyEvent e) {

myTank.keyReleased(e);

}

@Override

public void keyPressed(KeyEvent e) {

myTank.keyPressed(e);

}

}

}

Tank類：

import java.awt.*;

import java.awt.event.*;

import java.util.Random;

public class Tank {

public static final int XSPEED = 5; //定義常量X軸速度

public static final int YSPEED = 5;

public static final int WIDTH = 30;

public static final int HEIGHT = 30;

//定義一個(gè)隨機(jī)數(shù)產(chǎn)生器，此時(shí)的Random類是java.util.Random，不同于Math中的

private static Random r = new Random(); //隨機(jī)數(shù)產(chǎn)生器只需要一個(gè)，所以定義成靜態(tài)，防止每次new一個(gè)坦克是都會(huì)產(chǎn)生一個(gè)隨機(jī)數(shù)產(chǎn)生器

private boolean good; //定義變量說(shuō)明是我方還是敵方坦克，為true表示我方坦克

private boolean live = true; //定義變量說(shuō)明是坦克是否存活

TankClient tc;

private int x , y; //定義變量畫圓圈(坦克)時(shí)四邊形左上點(diǎn)的x、y左邊

private int oldX , oldY; //定義坦克上個(gè)位置的坐標(biāo)

private boolean bL = false, bU = false, bR = false, bD = false; //定義變量左上右下的按鍵是否被按下

enum Direction {L,LU,U,RU,R,RD,D,LD,STOP}; //定義枚舉類型，值為左、左上、上、右上、右、右下、下、左下、停止

private Direction dir = Direction.STOP; //定義變量坦克的方向

private Direction ptDir = Direction.D; //定義變量坦克炮筒的方向，起初向下

private int step = r.nextInt(12) + 3; //定義坦克朝著一個(gè)方向移動(dòng)幾步

public Tank(int x, int y, boolean good) {

this.x = x;

this.y = y;

this.good = good;

this.oldX = x;

this.oldY =y;

}

public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {

this(x, y, good); //相當(dāng)于調(diào)用上面的構(gòu)造方法

this.dir = dir;

this.tc = tc;

}

public void drawTank(Graphics g) {

if(!live) {

if(!good) {

tc.tanks.remove(this);

}

return; //如果坦克沒(méi)有存活就直接返回，不用畫坦克了

}

Color c = g.getColor(); //取得g(以后稱為畫筆)的顏色

if(good) g.setColor(Color.RED);

else g.setColor(Color.BLUE);

g.fillOval(x, y, WIDTH, HEIGHT); //"畫圓",利用填充一個(gè)四邊形(四邊形的內(nèi)切圓)，參數(shù)分別代表：四邊形左上點(diǎn)的坐標(biāo)X，Y，寬度，高度

g.setColor(c); //用完畫筆后把畫筆默認(rèn)的顏色(黑色)設(shè)置回去

//根據(jù)炮筒的方向，畫直線代表炮筒

switch (ptDir) {

case L:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y+Tank.HEIGHT/2);

break;

case LU:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y);

break;

case U:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH/2, y);

break;

case RU:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y);

break;

case R:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y+Tank.HEIGHT/2);

break;

case RD:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y+Tank.HEIGHT);

break;

case D:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH/2, y+Tank.HEIGHT);

break;

case LD:

g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y+Tank.HEIGHT);

break;

}

move(); //每次按鍵都會(huì)重畫，就會(huì)調(diào)用drawTank，在這里重畫坦克的此時(shí)位置

}

public void keyPressed(KeyEvent e) {

int key = e.getKeyCode(); //得到按鍵的虛擬碼，再和下面的KeyEvent.VK_LEFT等虛擬碼比較看是否是某按鍵

switch (key) {

case KeyEvent.VK_LEFT:

bL = true;

break;

case KeyEvent.VK_UP:

bU = true;

break;

case KeyEvent.VK_RIGHT:

bR = true;

break;

case KeyEvent.VK_DOWN:

bD = true;

break;

}

locateDraction();

if (dir != Direction.STOP) {

ptDir = dir;

}

}

public void keyReleased(KeyEvent e) {

int key = e.getKeyCode();

switch (key) {

case KeyEvent.VK_R: //按R就發(fā)射子彈調(diào)用fire方法

fire(); //只有松開R才能發(fā)出子彈

break;

case KeyEvent.VK_LEFT:

bL = false;

break;

case KeyEvent.VK_UP:

bU = false;

break;

case KeyEvent.VK_RIGHT:

bR = false;

break;

case KeyEvent.VK_DOWN:

bD = false;

break;

}

locateDraction();

}

//通過(guò)上右下的按鍵是否被按下判斷坦克要運(yùn)動(dòng)的方向

void locateDraction() {

if(bL && !bU && !bR && !bD) dir =Direction.L;

else if(bL && bU && !bR && !bD) dir =Direction.LU;

else if(!bL && bU && !bR && !bD) dir =Direction.U;

else if(!bL && bU && bR && !bD) dir =Direction.RU;

else if(!bL && !bU && bR && !bD) dir =Direction.R;

else if(!bL && !bU && bR && bD) dir =Direction.RD;

else if(!bL && !bU && !bR && bD) dir =Direction.D;

else if(bL && !bU && !bR && bD) dir =Direction.LD;

else if(!bL && !bU && !bR && !bD) dir =Direction.STOP;

}

public void move() {

oldX = x;

oldY = y;

switch (dir) {

case L:

x -= XSPEED;

break;

case LU:

x -= XSPEED;

y -= YSPEED;

break;

case U:

y -= YSPEED;

break;

case RU:

x += XSPEED;

y -= YSPEED;

break;

case R:

x += XSPEED;

break;

case RD:

x += XSPEED;

y += YSPEED;

break;

case D:

y += YSPEED;

break;

case LD:

x -= XSPEED;

y += YSPEED;

break;

case STOP:

break;

}

if(this.dir != Direction.STOP) {

this.ptDir = this.dir;

}

//防止坦克出界

if (x < 0) x = 0;

if (y < 25) y = 25; //考慮了標(biāo)題欄的高度

if (x + Tank.WIDTH > TankClient.GAME_WIDTH) x = TankClient.GAME_WIDTH - Tank.WIDTH;

if (y + Tank.HEIGHT > TankClient.GAME_HEIGHT) y = TankClient.GAME_HEIGHT - Tank.HEIGHT;

if (!good) {

Direction[] dirs = Direction.values(); //把枚舉轉(zhuǎn)換成數(shù)組

if (step == 0) {

int rn = r.nextInt(dirs.length);

dir = dirs[rn]; //如果移動(dòng)步數(shù)為0就改變方向

step = r.nextInt(12) + 3;

}

step --;

if(r.nextInt(40) > 37) this.fire();

}

}

public void stay() {

x = oldX;

y = oldY;

}

//坦克開火，就new一個(gè)子彈出來(lái)

private Missile fire() {

if(!live) return null;

int x = this.x + Tank.WIDTH/2 - Missile.WIDTH/2; //讓子彈從坦克中心打出

int y = this.y + Tank.HEIGHT/2 - Missile.HEIGHT/2;

Missile m = new Missile(x, y,good, ptDir , this.tc);

tc.missiles.add(m); //每new一個(gè)Missile對(duì)象就把他裝到集合中

return m; //返回的m，其他地方可調(diào)用可不調(diào)用

}

public Rectangle getRect() {

return new Rectangle(x, y, WIDTH, HEIGHT); //得到坦克的探測(cè)方塊，Rectangle是java.awt包中專門用于游戲碰撞的類

}

public boolean isLive() {

return live;

}

//Tank類的成員方法可生成對(duì)應(yīng)的get和set方法，那么在其他類中就可以訪問(wèn)了

public void setLive(boolean live) {

this.live = live;

}

public boolean isGood() {

return good;

}

//檢測(cè)坦克是否撞墻

public boolean collidesWithWall(Wall w) {

if(this.live && this.getRect().intersects(w.getRect())) {

stay(); //如果坦克撞到墻就讓他回到上一個(gè)位置

return true;

}

return false;

}

//檢測(cè)坦克是否相撞,java.util.List接口或者類的另一種寫法，java.awt中也有List，所以要寫明確

public boolean collidesWithTanks(java.util.List tanks) {

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

Tank t = tanks.get(i);

if (this != t) {

if(this.live && t.isLive() && this.getRect().intersects(t.getRect())) {

this.stay();

t.stay();

return true;

}

}

}

return false;

}

}

Missile類：

import java.awt.*;

import java.util.List;

public class Missile {

public static final int XSPEED = 10;

public static final int YSPEED = 10;

public static final int WIDTH = 10;

public static final int HEIGHT = 10;

int x, y;

Tank.Direction dir;

private boolean good; //定義變量表示是否是我方子彈

private boolean live = true; //定義一個(gè)判斷子彈是否出界的變量

private TankClient tc;

public Missile(int x, int y, Tank.Direction dir) {

this.x = x;

this.y = y;

this.dir = dir;

}

public Missile(int x, int y,boolean good, Tank.Direction dir, TankClient tc) {

this(x, y, dir);

this.good = good;

this.tc = tc;

}

public void drawMissile(Graphics g) {

if(!live) {

tc.missiles.remove(this);

return;

}

Color c = g.getColor();

g.setColor(Color.BLACK);

g.fillOval(x, y, WIDTH, HEIGHT);

g.setColor(c);

move();

}

private void move() {

switch (dir) {

case L:

x -= XSPEED;

break;

case LU:

x -= XSPEED;

y -= YSPEED;

break;

case U:

y -= YSPEED;

break;

case RU:

x += XSPEED;

y -= YSPEED;

break;

case R:

x += XSPEED;

break;

case RD:

x += XSPEED;

y += YSPEED;

break;

case D:

y += YSPEED;

break;

case LD:

x -= XSPEED;

y += YSPEED;

break;

}

if (x < 0 || y < 0 || x > tc.GAME_WIDTH || y > tc.GAME_HEIGHT) {

live = false;

}

}

public boolean isLive() {

return live;

}

public Rectangle getRect() {

return new Rectangle(x, y, WIDTH, HEIGHT); //得到子彈的探測(cè)方塊，Rectangle是java.awt包中專門用于游戲碰撞的類

}

//判斷子彈是否打到了坦克

public boolean hitTank(Tank t) {

//intersects是Rectangle的一個(gè)方法；t.isLive()是為了判斷坦克是否存活，如果沒(méi)有則打掉這個(gè)坦克后，之后的子彈到達(dá)原來(lái)這個(gè)坦克的位置就會(huì)消失

if (this.live && this.getRect().intersects(t.getRect()) && t.isLive() && this.good != t.isGood()) {

t.setLive(false);

this.live = false;

Explode e = new Explode(x, y, tc);

tc.explodes.add(e);

return true;

}

return false;

}

public boolean hitTanks(List tanks) {

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

if (hitTank(tanks.get(i))) {

return true;

}

}

return false;

}

public boolean hitWall(Wall w) {

if(this.live && this.getRect().intersects(w.getRect())) {

this.live = false;

return true;

}

return false;

}

}

Explode類：

import java.awt.*;

//爆炸類(爆炸的英文：explode)

public class Explode {

int x, y;

private TankClient tc;

private boolean live = true;

int[] diameter = {4, 10, 20, 36, 56, 24, 12, 6}; //定義畫不同直徑的圓表示爆炸(直徑的英文:diameter)

int step = 0; //定義變量代表畫爆炸的圓畫到第幾個(gè)了

public Explode(int x, int y, TankClient tc) {

this.x = x;

this.y = y;

this.tc = tc;

}

public void draw(Graphics g) {

if(!live) {

tc.explodes.remove(this);

return;

}

if (step == diameter.length) {

live = false;

step = 0;

return;

}

Color c = g.getColor();

g.setColor(Color.ORANGE);

g.fillOval(x, y, diameter[step], diameter[step]);

g.setColor(c);

step ++ ;

}

}

Wall類：

import java.awt.*;

public class Wall {

private int x, y, w, h;

private TankClient tc;

public Wall(int x, int y, int w, int h, TankClient tc) {

this.x = x;

this.y = y;

this.w = w;

this.h = h;

this.tc = tc;

}

public void draw(Graphics g) {

g.fillRect(x, y, w, h);

}

public Rectangle getRect() {

return new Rectangle(x, y, w, h);

}

}

知識(shí)點(diǎn)回顧：

1、碰撞檢測(cè)的輔助類Rectangle，屬于java.awt.Rectangle中,用法：

==>首先獲取兩個(gè)要檢測(cè)物體的邊界，相當(dāng)于一個(gè)Rectangle對(duì)象，可以給他們定義相應(yīng)的getRect()方法，返回值為一個(gè)Rectangle對(duì)象，在函數(shù)內(nèi)return

new Rectangle(x, y, w, h);

==>定義一個(gè)方法判斷是否碰撞到了，返回值為boolean，物體1.getRect().intersects(物體2.getRect())的返回值也是一個(gè)boolean類型，返回真則表示碰撞到了，再執(zhí)行相應(yīng)的功能，反之亦然。

2、將枚舉轉(zhuǎn)換成數(shù)組：枚舉名.values()，返回的是相應(yīng)的數(shù)組。如：Direction[] dirs = Direction.values();返回的是Direction類型的數(shù)組

3、隨機(jī)數(shù)的使用：

==>java.util.Random比較方便，可以直接產(chǎn)生隨機(jī)整數(shù)，使用時(shí)先定義一個(gè)隨機(jī)數(shù)產(chǎn)生器，如：定義隨機(jī)數(shù)產(chǎn)生器：Random

r = new Random(); 產(chǎn)生隨機(jī)數(shù)整數(shù)：r.nextInt(12)表示產(chǎn)生一個(gè)0-11的隨機(jī)整數(shù)

==>math.random()產(chǎn)生的是一個(gè)0-1的數(shù)，使用時(shí)一般要通過(guò)計(jì)算轉(zhuǎn)換，比較麻煩

總結(jié)

以上是生活随笔為你收集整理的java坦克大战爆炸效果_Java坦克大战 (五) 之产生敌方坦克和爆炸效果的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。