Java练习之坦克大战！！！复制可以直接用！！！文章最后有飞机大战代码！！！

于 2021-08-19 20:30:32 发布
阅读量688 收藏 6
点赞数 2
分类专栏： JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53262248/article/details/119801305
版权

用Java写一个入门游戏——坦克大战！
源代码！！！复制可以直接用！！！
文章最后还有飞机大战代码！！！
本代码写的较为入门，有需要的铁铁们可以去看看！！！
在往期我们讲解了窗口、循环、数组和继承的一些知识之后我们将这些知识整理起来便可以自己来写一个java的小游戏；
（ps：新来的铁铁们可以去看看我往期的内容）
在这里插入图片描述

好啦那么我们就直接进入正题了哈！

步骤1

首先就需要用到我们昨天学到的知识——java的继承，我们先去写一个父类用来把坦克大战想去表述的功能全部都写进去~

import java.awt.*;
import java.awt.event.*;
import java.util.List;
import java.util.ArrayList;
import java.applet.Applet;
import java.applet.AudioClip;
import java.io.File;
import java.net.URL;


public class TankClient extends Frame{     //界面大小
public static final int GAME_WIDTH=800;
public static final int GAME_HEIGHT=600;
//Image belmg=GameUtil.getImage("D:\\1"+".jpg");
Tank myTank =new Tank(800,290,true,Tank.Direction.STOP,this);//坦克出生位置
jia j1=new jia(750,260,60,10,this),j2=new jia(750,320,60,10,this),j3=new jia(740,260,10,70,this);   //定义家
Wall w1=new Wall(300,200,20,200,this),w2=new Wall(500,100,150,20,this),/*w3=new Wall(750,270,50,10,this),w4=new Wall(750,310,50,10,this),*/
w5=new Wall(500,400,10,90,this),w6=new Wall(85,100,60,9,this);//定义墙
cao  c1=new cao(150,100,50,50,this), c2=new cao(600,500,50,50,this);         //定义草丛

List<Explode>explodes=new ArrayList<Explode>();
List<Missile>missiles=new ArrayList<Missile>();
List<Tank> tanks=new ArrayList<Tank>();
Image offScreenImage=null; 

Blood b=new Blood();             //新建血类
Blood1 b1=new Blood1();
Blood2 b2=new Blood2();

public void paint(Graphics g){        //显示参数
g.drawString("有效子弹数量："+missiles.size(),10,50);
g.drawString("爆炸数量："+explodes.size(),10,65);
g.drawString("敌军数量："+tanks.size(),10,85);
g.drawString("剩余血量："+myTank.getLife(),10,100);
g.drawString("家",750,285);
g.drawString("草丛",205,155);
g.drawString("草丛",605,490);
//g.drawString(bglmg,0,0,null);
if(tanks.size() ==6){
for(int i=0;i<18;i++){            //第一次敌人数量
	tanks.add(new Tank(50+40*(i+1),50,false,Tank.Direction.D,this));
	
	}
}
if(tanks.size() ==4){
for(int i=0;i<13;i++){            //第二次敌人数量
	tanks.add(new Tank(50+40*(i+1),50,false,Tank.Direction.D,this));
	
	}
}
if(tanks.size() ==2){
for(int i=0;i<11;i++){            //第三次敌人数量
	tanks.add(new Tank(50+40*(i+1),50,false,Tank.Direction.D,this));
	
	}
}
if(tanks.size() ==1){
for(int i=0;i<18;i++){            //第四次敌人数量
	tanks.add(new Tank(50+40*(i+1),50,false,Tank.Direction.D,this));
	
	}
}
if(tanks.size() ==0){
for(int i=0;i<30;i++){            //第五次敌人数量
	tanks.add(new Tank(50+40*(i+1),50,false,Tank.Direction.D,this));
	
	}
}
for(int i=0;i<missiles.size();i++){       //防止子弹穿墙
Missile m=missiles.get(i);
m.hitTanks(tanks);
m.hitTank(myTank);
m.hitWall(w1);
m.hitWall(w2);
m.hitjia(j1);
m.hitjia(j2);
m.hitjia(j3);
m.hitWall(w5);
m.hitWall(w6);
m.hitcao(c1);
m.hitcao(c2);
m.draw(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);
t.collidesWithWall(w2);
t.collidesWithjia(j1);
t.collidesWithjia(j2);
t.collidesWithjia(j3);
t.collidesWithWall(w5);
t.collidesWithWall(w6);
t.collidesWithTanks(tanks);
t.draw(g);
}
//我军坦克撞墙
myTank.draw(g);
myTank.eat(b);
myTank.eat(b1);
myTank.eat(b2);
myTank.collidesWithWall(w1);
myTank.collidesWithWall(w2);
myTank.collidesWithWall(w5);
myTank.collidesWithWall(w6);
w1.draw(g);
w2.draw(g);
j1.draw(g);
j2.draw(g);
j3.draw(g);
w5.draw(g);
w6.draw(g);
c1.draw(g);
c2.draw(g);
b.draw(g);
b1.draw(g);
}
public void update(Graphics g){
if(offScreenImage==null){
offScreenImage=this.createImage(GAME_WIDTH,GAME_HEIGHT);
}
Graphics gOffScreen=offScreenImage.getGraphics();
Color c=gOffScreen.getColor();
gOffScreen.setColor(Color.WHITE);
gOffScreen.fillRect(0,0,GAME_WIDTH,GAME_HEIGHT);
gOffScreen.setColor(c);
paint(gOffScreen);
g.drawImage(offScreenImage,0,0,null);
}

	public void lauchFrame(){
	
	for(int i=0;i<10;i++){            //初始敌人数量
	tanks.add(new Tank(50+40*(i+1),50,false,Tank.Direction.D,this));//敌人大小
	}
	
		//this.setLocation(400,300);
		this.setSize(GAME_WIDTH,GAME_HEIGHT);
		this.setTitle("坦克战争");     //游戏命名
		this.addWindowListener(new WindowAdapter(){
		public void windowClosing(WindowEvent e){
		System.exit(0);
		}
	});
	this.setResizable(false);
	this.setBackground(Color.WHITE);
	this.addKeyListener(new KeyMonitor());
		setVisible(true);
		
		new Thread(new PaintThread()).start();
	}

	public static void main(String[] args) {
		try{URL url = new File("D:\\java\\DAA.wav").toURI().toURL();//找到背景音乐所在文件
AudioClip audioClip = new Applet().newAudioClip(url);
audioClip.loop();
 }//循环播放
 catch(Exception e){ }
		TankClient tc=new TankClient();
		tc.lauchFrame();
	
	}
	private class PaintThread implements Runnable{
	public void run(){
	while(true){
	repaint();
	try{
	Thread.sleep(100);//频率
	
	}catch (InterruptedException e){
	e.printStackTrace();}
	}
	}

}
//按键处理
public class KeyMonitor extends KeyAdapter{
public void keyReleased(KeyEvent e){
myTank.keyReleased(e);
}
public void keyPressed(KeyEvent e){
myTank.keyPressed(e);
}
}
 
}

步骤2：

下面我们来写一下坦克这个类：

import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Tank{
public static final int XSPEED=10;         // 坦克速度
public static final int YSPEED=10;
public static final int WIDTH=35;          //子弹速度
public static final int HEIGHT=35;
private boolean live=true;

private int life=100;          //坦克生命值
private BloodBar bb =new BloodBar();
TankClient tc;

private boolean good;

private int x,y;        //位置
private int oldX,oldY;  //原来位置
private static Random r=new Random();

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(20)+8;//敌人坦克炮弹频率
public Tank(int x,int y,boolean good){
this.x=x;
this.y=y;
this.oldX=x;
this.oldY=y;
this.good=good;
}
public Tank(int x,int y,boolean good,Direction dir,TankClient tc){
this (x,y,good);
this.dir=dir;
this.tc=tc;
}
public void draw(Graphics g){
if(!live){
if(!good)tc.tanks.remove(this);
else return;
} 

Color c=g.getColor();
if(good)
g.setColor(Color.BLUE);  //我方坦克颜色
else g.setColor(Color.CYAN);//敌军坦克颜色
g.fillOval(x,y,WIDTH,HEIGHT);
g.setColor(c);
if(good) bb.draw(g);//画出血条

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();
}
void move(){            //移动
this.oldX=x;
this.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<30)y=30;
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();
if(step ==0){
step=r.nextInt(15)+5;
int rn=r.nextInt(dirs.length);
dir=dirs[rn];
}
step--;
if(r.nextInt(40)>38) this.fire();//敌军炮弹速度
}

}
private void stay() {
x=oldX;
y=oldY;
}
public void keyPressed(KeyEvent e){
int key=e.getKeyCode();         //按键处理
switch(key){
case KeyEvent.VK_K:
if(!this.live){            //复活
this.live =true;
this.life=100;
}
break;
case KeyEvent.VK_CONTROL:
fire();
break;
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;
	case KeyEvent.VK_ENTER:
superFire();
break;	
}
locateDirection();
}
void locateDirection(){
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 keyReleased(KeyEvent e){
int key=e.getKeyCode();
switch(key){
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;
		
}
locateDirection();
}
public 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);
return m;
}
public Missile fire(Direction dir){
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,dir,this.tc);
tc.missiles.add(m);
return m;
}
public Rectangle getRect(){
return new Rectangle(x,y,WIDTH,HEIGHT);

}
public boolean isLive(){
return live;
}
public void setLive(boolean live){
this.live=live;
}
public boolean isGood(){
return good;
}
// 坦克撞墙
public boolean collidesWithWall(Wall w){
if(this.live && this.getRect().intersects(w.getRect())){
this.stay();
return true;
}
return false;
}
//撞草丛
public boolean collidesWithcao(cao w){
if(this.live && this.getRect().intersects(w.getRect())){
this.stay();
return true;
}
return false;
}
//撞房子
public boolean collidesWithjia(jia w){
if(this.live && this.getRect().intersects(w.getRect())){
this.stay();
return true;
}
return false;
}

public boolean collidesWithTanks(java.util.List<Tank>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;
}
private void superFire(){                              //超级炮弹
Direction[] dirs=Direction.values();
for(int i=0;i<8;i++){
tc.missiles.add(fire(dirs[i]));
}
}
public void setLife(int life){
this.life=life;
}
public int getLife(){
return life;
}
private class BloodBar{
public void draw(Graphics g){      //显示血条
Color c=g.getColor();
g.setColor(Color.RED);
g.drawRect(x,y-10,WIDTH,10);
int w=WIDTH*life/100;
g.fillRect(x,y-10,w,10);
g.setColor(c);

}
}
public boolean eat(Blood b){
if(this.live && b.isLive() && this.getRect().intersects(b.getRect())){
this.life=100;
b.setLive(false);
return true;
}
return false;
}
public boolean eat(Blood1 b1){
if(this.live && b1.isLive()&& this.getRect().intersects(b1.getRect())){
this.life=20;
b1.setLive(false);
return true;
}
return false;
}
public boolean eat(Blood2 b2){
if(this.live  && this.getRect().intersects(b2.getRect())){
this.life=100;

return true;
}
return false;
}

}

步骤3：

下面来写一下子弹这个类！

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;
public 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 draw(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>TankClient.GAME_WIDTH||y>TankClient.GAME_HEIGHT){
live=false;
tc.missiles.remove(this);
}

}
public boolean isLive(){
return live;
}

public Rectangle getRect(){            //碰见
return new Rectangle(x,y,WIDTH,HEIGHT);
}
public boolean hitTank(Tank t){          //打坦克
if(this.live && this.getRect().intersects(t.getRect())&& t.isLive() && this.good!=t.isGood()){
if(t.isGood()) {
 t.setLife(t.getLife()-10);                                //命中坦克掉血值
 if(t.getLife() <=0) t.setLive(false);   
}
else {
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<Tank> 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;
}
public boolean hitcao(cao w){                               //模拟草丛隐身
if(this.live && this.getRect().intersects(w.getRect())){
this.live=false;
return true;
}
return false;
}
public boolean hitjia(jia w){                               //模拟家
if(this.live && this.getRect().intersects(w.getRect())){
this.live=false;
return true;
}
return false;
}
}

步骤4：

下面来写一下子弹命中坦克产生爆炸这个类：

import java.awt.*;

public class Explode {
int x,y;
private boolean live =true;

private TankClient tc;

int[ ] diameter ={4,7,12,18,26,32,49,30,14,6};           //爆炸范围
int step=0;
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 ++;

}
}

步骤5：

下面来写一下游戏中障碍物这个类：

import java.awt.*;

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

this.x=x;
this.y=y;
this.h=h;
this.w=w;
this.tc=tc;

}
public void draw(Graphics g){
Color c=g.getColor();//设置颜色
g.setColor(Color.MAGENTA);
g.fillRect(x,y,w,h);//写出墙类
g.setColor(c);
}
public Rectangle getRect(){
return new Rectangle (x,y,w,h);
}
}

import java.awt.*;

public class cao {
private TankClient tc;
int x,y,w,h;
public cao (int x,int y, int w, int h,TankClient tc){

this.x=x;
this.y=y;
this.h=h;
this.w=w;
this.tc=tc;

}
public void draw(Graphics g){
Color c=g.getColor();//设置颜色
g.setColor(Color.GREEN);
g.fillRect(x,y,w,h);//写出草丛类
g.setColor(c);
}
public Rectangle getRect(){
return new Rectangle (x,y,w,h);
}
}

步骤6：

下面来写一下游戏中坦克回血的设定：

import java.awt.*;

public class Blood{
int x,y,w,h;
TankClient tc;
int step = 0;
private boolean live = true;
private int[][]pos={                        //血块运动轨迹
{80,70},
{80,100},
{90,120},
{100,100},
{100,130},
{180,90},
{110,92},
{155,55},
{80,60}
};
public Blood(){
x=pos[0][0];
y=pos[0][1];
w=h=15;
}
public void draw(Graphics g){
if(!live)
return ;
Color c=g.getColor();
g.setColor(Color.PINK);
g.fillRect(x,y,w,h);
g.setColor(c);
move();
}
private void move(){
step++;
if(step ==pos.length){
step=0;
}
x=pos[step][0];
y=pos[step][1];
}
public Rectangle getRect(){
return new Rectangle(x,y,w,h);
}
public boolean isLive(){
return live;
}
public void setLive(boolean live){
this.live=live;
}
}

步骤7：

下面来写一下游戏中陷阱类！

import java.awt.*;

public class Blood1{                  //地雷类
int x,y,w,h;
TankClient tc;
int step = 0;
private boolean live = true;
private int[][]pos={
{200,300},{200,310},{200,330}             //地雷轨迹
};
public Blood1(){
x=pos[0][0];
y=pos[0][1];
w=20;
h=10;
}
public void draw(Graphics g){
if(!live)
return ;
Color c=g.getColor();
g.setColor(Color.WHITE);                        //设置颜色
g.fillOval(x,y,w,h);
g.setColor(c);
move();
}
private void move(){
step++;
if(step ==pos.length){
step=0;
}
x=pos[step][0];    
y=pos[step][1];
}
public Rectangle getRect(){
return new Rectangle(x,y,w,h);
}
public boolean isLive(){
return live;
}
public void setLive(boolean live){
this.live=live;
}
}

步骤8：

下面我们来给坦克大战设置一个“泉水”吧！

import java.awt.*;

public class Blood2{            //家回血
int x,y,w,h;
TankClient tc;
int step = 0;
private boolean live = true;
private int[][]pos={
{760,285}                    //位置设置
};
public Blood2(){
x=pos[0][0];
y=pos[0][1];
w=20;
h=20;
}
public void draw(Graphics g){
Color c=g.getColor();
g.setColor(Color.WHITE);               //颜色设置
g.fillRect(x,y,w,h);
g.setColor(c);
move();
}
private void move(){
step++;
if(step ==pos.length){
step=0;
}
x=pos[step][0];    
y=pos[step][1];
}
public Rectangle getRect(){
return new Rectangle(x,y,w,h);
}

}

运行效果：

D:\Java>javac TankClient.java

D:\Java>java TankClient

D:\Java>

在这里插入图片描述
在这里插入图片描述
注意铁铁们！！！
大家可以打开声音，会有背景音乐的！！！

下面我把创建图形界面、背景音乐和另外一个小游戏（飞机大战）的教程放在下面链接中，铁铁们有需要可以去看看哈！

链接：https://pan.baidu.com/s/14BO6bN0iWyl1HIlsguCMyw
提取码：0136
———————————————————手动分割——————————————————————
好啦！
本期的内容到这里就结束了！
要是有疑问铁铁们可以直接评论区或者私信问我哈！
明天我会有点事；
但是日更不断！
明天我会给大家分享一写学习java的文件~~
（ps：主要不麻烦，哈哈哈）
那么我们明天见铁铁们！
在这里插入图片描述

java缝合怪
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java版飞机大战源码-TankWar:坦克大战，玩家坦克支持多种威力的子弹，而敌人在一定距离下具有侦测到你的能力
06-04
java版飞机大战源码 tankwar完整版本(jar文件, 源码)下载: 一. 关于tankwar: tankwar 是使用java开发的一个单机版的小游戏 (未使用任何游戏引擎). 和90经典版的坦克大战有些不同, 这里是纯坦克之间的战争, 英雄坦克并不用保护它的家. 特色: 游戏共设6个关卡. (支持无限关卡) 关卡设置中包括敌人坦克数量, 移动速度, 子弹速度, 以及子弹的杀伤力, 炸弹数量, 飞弹数量, 移动随机因子, 子弹发送频率因子. 英雄坦克的设置同上, 更改org.lionsoul.tankwar.LionBarriers可以加入更多关卡, 修改现有关卡选项. 游戏子弹分为三类: (1). 普通子弹(移动速度和杀伤力小), (2). 普通炸弹(移动速度和杀伤力一般), (3). 超级飞弹(移动速度很快,并且杀伤力很强). 关于游戏地图: 当前默认地图算法为随机文字点矩阵地图, 即,地图是依据由文字生成的. 关于坦克: 分为两个大类, 英雄坦克(玩家), 敌人坦克. 敌人坦克分类: (1). 随机坦克. (移动和子弹发射,以及发射频率全是随机, 可以控制随机因子来控制)
Java项目开发—坦克大战（附源码）
m0_72882572的博客
10-27 2844
今天给小伙伴们分享一个坦克大战游戏的详细编写流程，即使你是刚入门java的新手，只要你简单掌握了该游戏所需要的javase基础知识，便可以跟随教程视频完成属于你自己的坦克大战游戏！同时还可以加深和巩固你对面向对象知识的理解。
初学JAVA时写的飞机大战和坦克大战精备注版
AlbertMin的博客
08-12 470
初学JAVA时写的飞机大战和坦克大战精备注版 坦克大战是以尚学堂马士兵基础写的,1.3版本还有些bug,运行时间越长越卡, 飞机大战加入背景滚动和爆炸效果,菜单栏. 手打备注,坦克大战bug目前不知卡顿原因,望大佬评论解决.练手项目,初学Java,望能在这里继续前行. 源码用eclipse(UTF-8)写的,有兴趣可以下载评论. ...
飞扬的小鸟，飞机大战，坦克大战Java版游戏
03-03
飞扬的小鸟，飞机大战，坦克大战Java版小游戏，代码简单，主要练习
java版飞机大战源码-TankBattle:基于Netty的联机版坦克大战
06-04
java版飞机大战源码 基于Netty的联机版坦克大战 项目介绍 该项目实现了联机版坦克大战，项目包括客户端与服务端 项目使用技术： 使用Netty实现客户端和服务端之间的通讯 使用Marshalling作为编解码技术 游戏界面使用java自带的swing与awt进行编写 使用Spring的依赖注入与java的反射机制简化了消息类型的判定 使用Mysql数据库 使用log4j记录日志 实现功能： 人机对战 多玩家开房间对战 碰撞检测 机器坦克使用A*算法，进行路径规划 机器坦克有巡逻范围的概念，当玩家坦克进入其巡逻范围，机器坦克才会使用A*寻路前往玩家坦克的位置 限制了子弹的飞行距离，当子弹到达飞行距离上限、击中障碍物、碰到边界时，子弹会爆炸。子弹爆炸是范围性伤害，在爆炸范围内，砖块和坦克都会被消灭 游戏支持多地图，玩家可以选择任意一幅地图 实现心跳机制，断线重连功能 在人机对战模式中，支持进度保存 实现用户登录、注册等功能 效果展示 在人机对战模式中，有多幅地图可供选择：           玩家对战模式： 使用方式 本项目使用maven构建，原则上不需要用户自行下载各种jar包，但
坦克大战java源代码
10-08
适合新手的java练习小项目，坦克大战游戏大家熟悉，将通过阅读代码了解游戏的原理
java坦克大战小游戏
11-24
利用javaSE面对对象基础制作的坦克大战，主要用于练习java面对对象基础。里面已经把java代码打包成jar包，在本机装有jdk的情况下，可以直接点解扩展名为.bat文件直接运行。
JAVA+Swing坦克大战
04-17
适合新手练习，有面向对象和多线程。支持自定义游戏。
java坦克大战小游戏和中间的某些练习.zip
最新发布
10-13
java坦克大战小游戏和中间的某些练习.zipjava坦克大战小游戏和中间的某些练习.zip java坦克大战小游戏和中间的某些练习.zipjava坦克大战小游戏和中间的某些练习.zip java坦克大战小游戏和中间的某些练习.zipjava坦克...
练习用java语言编写坦克大战的游戏.zip
08-05
用java写的项目，源码都经测试过，真实可靠，欢迎大家下载学习。用java写的项目，源码都经测试过，真实可靠，欢迎大家下载学习。用java写的项目，源码都经测试过，真实可靠，欢迎大家下载学习。用java写的项目，源码...
基于Java的坦克大战游戏（含代码和报告）
07-28
基于Java的坦克大战游戏（含代码和报告）
飞机大战java源代码
04-01
连连看java源代码，用纯JAVA做得飞机大战，提供源代码下载，附带图片，共享给大家
坦克大战完整源代码
06-25
无需配置环境，下载可用，VC6.0编译环境，完整实现fc蓝白机坦克大战的完整源代码。
C++坦克大战完整代码.zip
07-19
这是我找来的坦克大战完整代码，拿去参考 玩法如下：按P发射，按WASD进行移动，消灭敌人，守护阵营
用java编写——贪吃蛇（复制！粘贴！运行！）
08-20
基于java编写的贪吃蛇小游戏，初学者自信爆棚
坦克大战Java项目四
sunshineFFSFor的博客
10-13 386
任务4 我方坦克发射子弹 按住空格，发射子弹 -----键盘的事件监听，按住空格，出现子弹，子弹绘制，坐标，方向，速度， 定义子弹类 public class shot { private int x; private int y; private int direction; private int speed=4; public shot(int ...
飞机大战，坦克大战源码、简单仿记事本、错题本源码及笔记
m0_57249797的博客
07-04 760
待更新
java swing 打字母 小游戏 复制粘贴可以
responsecool的专栏
05-14 1993
package com.word; import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.Graphics; import java.awt.Toolkit; import java.awt.event.KeyEvent; import java.awt.event.KeyL
delphi简单的小项目_JAVA 经典小项目—贪吃蛇的简单实现
weixin_39705794的博客
11-29 332
在我们学习java的时候，为了提高我们的兴趣，我们经常会使用所学到的知识去做一些小游戏，这篇文章就介绍了一个经典而且好理解的小游戏-贪吃蛇。一、使用知识JframeGUI双向链表线程二、使用工具IntelliJ IDEAjdk 1.8三、开发过程3.1素材准备首先在开发之前应该准备一些素材，图片和音乐。 3.2 开发过程3.2.1 创建项目首先进入idea首页 open一个你想放项目的文件夹 进入...
可以运行的java 坦克大战游戏完整 代码
05-10
但是，你可以尝试在互联网上搜索相关的Java坦克大战游戏代码。以下是一些可能有用的资源： - GitHub上的Java坦克大战游戏代码库：https://github.com/topics/java-tank-game - 码云上的Java坦克大战游戏代码库：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

java缝合怪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值