java单机版坦克游戏（尚学堂）

最新推荐文章于 2022-05-11 22:04:14 发布
最新推荐文章于 2022-05-11 22:04:14 发布
阅读量1.2k 收藏
点赞数
分类专栏： java 文章标签： java 游戏 import class random null

界面客户端 TankClient.java：

package com.rs;

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

import javax.swing.*;



public class TankClient extends JFrame{
	public static final int GAME_WIDTH=800;//常量名字母大写
	public static final int GAME_HEIGHT=600;
	

	Tank myTank=new Tank(50,50,true,Tank.Direction.STOP, this);
	
	Wall w1=new Wall(200,200,20,150,this),w2=new Wall(300,100,300,20,this);
	
	List<Explode> explodes=new ArrayList<Explode>();
	List<Missile> missiles=new ArrayList<Missile>();
	List<Tank> tanks=new ArrayList<Tank>();
	
	Image offScreenImage=null;
	
	public void paint(Graphics g) {//面向对象方法
		g.drawString("Missiles-count:"+missiles.size(),10,45);
		g.drawString("Explodes-count:"+explodes.size(),10,60);
		g.drawString("Tanks-count:"+tanks.size(),10,75);
		g.drawString("Tanks-lift:"+myTank.getLife(),10,90);

		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.draw(g);
		}	
		
		for(int j=0;j<explodes.size();j++){
			Explode e=explodes.get(j);
			e.draw(g);
		}
		
		for(int k=0;k<tanks.size();k++){
			Tank t=tanks.get(k);
			t.collidesWithWall(w1);
			t.collidesWithWall(w2);
			t.collidesWithTank(tanks);
			t.draw(g);
		}
			
		
		myTank.draw(g);
		w1.draw(g);
		w2.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.GRAY);
		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.setTitle("<MyTankWar>");
		this.setBounds(320,150,GAME_WIDTH,GAME_HEIGHT);		
		setResizable(false);
		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
		setBackground(Color.gray);
		setVisible(true);
		
		this.addKeyListener(new KeyMonitor());
		new Thread(new TankThread()).start();
	}

	private static final long serialVersionUID = 1L;

	public static void main(String[] args) {
		TankClient tc=new TankClient();
		tc.lauchFrame();
	}
	
	private class TankThread implements Runnable{

		public void run() {
			while(true){
				repaint();
				try {
					Thread.sleep(50);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		
	}

	private class KeyMonitor extends KeyAdapter{

		public void keyReleased(KeyEvent e) {
			myTank.keyReleased(e);
		}

		public void keyPressed(KeyEvent e) {
			myTank.KeyPressed(e);			
		}		
	}
}

坦克类 Tank.java： 

package com.rs;

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

public class Tank {
	public static final int XSPEED = 5;
	public static final int YSPEED = 5;
	public static final int WIDTH = 30;
	public static final int HEIGHT = 30;

	private int x, y,oldX,oldY;

	TankClient tc;
	
	private BloodBar bb=new BloodBar();

	private boolean live=true;
	private boolean good;
	
	private static Random random=new Random();//一个就够了，所以设为static
	
	private int step = random.nextInt(12)+3;
	
	private int life = 100;

	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;// 炮筒默认方向

	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);
			}
			return;
		}
		Color c = g.getColor();
		if (good) {
			g.setColor(Color.CYAN);
		} else {
			g.setColor(Color.blue);
		}
		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();
	}

	private 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 < 25)
			y = 25;
		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 = random.nextInt(12)+3;
				int rn=random.nextInt(dirs.length);
				dir=dirs[rn];
			}	
			step--;
			
			if(random.nextInt(40)>38) this.fire();
		}		
		
	}
	
	public void stay(){
		x=oldX;
		y=oldY;
	}

	public void KeyPressed(KeyEvent e) {// 键盘按下
		int key = e.getKeyCode();
		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;
		}
		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_F:
			fire();
			break;
		case KeyEvent.VK_A:
			superFire();
			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;
		}
		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 collidesWithTank(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++) {
			fire(dirs[i]);
		}
	}

	public int getLife() {
		return life;
	}

	public void setLife(int life) {
		this.life = life;
	}
	
	private class BloodBar {
		public void draw(Graphics g){
			Color color=g.getColor();
			g.setColor(Color.red);
			g.drawRect(x, y+13, WIDTH, 5);
			int w=WIDTH*life/100;
			g.fillRect(x, y+13, w, 5);
			g.setColor(color);
		}
	}

}

子弹类 Missile.java： 

package com.rs;

import java.awt.*;
import java.util.List;


public class Missile {//Tank子弹类
	private static final int XSPEED = 10;
	private 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 live=true;
	private boolean good;
	
	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 draw(Graphics g){
		if(!live) {
			tc.missiles.remove(this);
			return;
		}
		
		Color c=g.getColor();
		
		if(!good){
			g.setColor(Color.blue);
		} else{
			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;
		case STOP:
			break;
		}
		
		if(x<0||y<0||x>TankClient.GAME_WIDTH||y>TankClient.GAME_HEIGHT){//出界
			live=false;
		}
	}

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

爆炸效果 Explode.java： 

package com.rs;

import java.awt.*;

public class Explode {// 爆炸（多幅图重碟在一起）
	int x, y;
	private boolean live = true;

	private TankClient tc;
	
	int[] diameter = { 5,  12,  26,  49,  20, 3 };
	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 ++;
	}
}

障碍物 Wall.java： 

package com.rs;

import java.awt.Graphics;
import java.awt.Rectangle;

public class Wall {
	int x,y,w,h;
	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);
	}
}


Y叔输得起
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初学2之坦克要求(我方坦克发射子弹移动)运用多线程来处理
m0_64028046的博客
07-25 112
java坦克大战代码
坦克大战（基于尚学堂版修改）
页面无法显示_(:з」∠)__
03-28 1295
大概用了两天的课余，一共四五个多小时的时间做的，一千行代码的小游戏。先将尚学堂版坦克大战，先看PPT自己写，不会实现的地方看视频，最终一点点做了出来（和尚学堂的代码多少有出入），然后根据自己的想法进行了修改： 1.      加强AI，优化了坦克撞墙不回头的问题 2.      敌我使用两种颜色子弹 3.      敌方坦克死光后，随机生成十辆坦克，并避免卡墙。 代码： Tank
java实现坦克大战
热门推荐
Wksycxy的博客
05-11 1万+
话不多说，直接上思维导图（比较粗略） 目录 ​窗口初始化 游戏父类的编写 添加坦克类 初始化子弹类 添加围墙、基地 添加游戏规则 窗口初始化 准备工作 首先创建一个TankWar项目，在scr相同路径下创建images、music文件夹，将需要使用的图片、音乐分别放在images、music中。创建一个com.tankwar（包），注意命名规范 窗口初始化 在com.tankwar中创建GamePanel类 import javax.swing.JFrame; public
单机版简单坦克大战源码
07-22
坦克大战，经典儿时游戏，树木、河流、血包、钢墙、鹰总部。
全套坦克大战源码
08-22
是网上比较经典的java大战源码，由浅入深，一步步实现各种功能，最后将整个项目写出，而不是因为过多的代码，导致思路不明确，不知道从何入手，是java必会经典题
java 坦克大战 单机版
12-02
java实现的坦克大战游戏，游戏画面画图实现。
基于java的雷电游戏【尚学堂·百战程序员】.zip
04-28
基于Java的雷电游戏是一款经典的飞行射击游戏，由尚学堂·百战程序员团队倾心打造。该游戏采用Java语言编写，具有良好的跨平台性和可扩展性，可以在各种平台上流畅运行，为玩家带来极致的游戏体验。 在雷电游戏中，...
尚学堂java教程学习 之 飞机游戏.zip
12-17
使用java开发的游戏项目源码，可用于毕业设计、课程设计、练手学习等
基于JAVA的推箱子游戏【尚学堂·百战程序员】.zip
04-28
这款游戏由尚学堂·百战程序员团队精心设计与开发，采用JAVA语言编写，具有良好的跨平台性和可扩展性。 游戏背景设定在一个迷宫般的场景中，玩家扮演角色需要将箱子推到指定位置，以完成关卡目标。游戏提供了多个...
坦克大战单机版源程序
04-07
跟着尚学堂马士兵老师视频做的一个坦克大战单机版的游戏，其中的ppt包含了每个阶段所做的事情。
TankWar 单机（JAVA版） 版本0.4~版本0.6 让坦克动起来
苏苏爱自由
10-05 2386
版本0.4的项目要求是让坦克动起来 由于在版本0.6也是让坦克听从我们指挥  等会再写 在这里主要是建立一个屏幕刷新线程  使屏幕达到时时刷新的效果 代码如下： public class updateThread extends Thread{ @Override public void run() { // TODO Auto-generated method stub
尚学堂（java）1到13章所有练习题答案详解
Guo_ping'blog
09-21 5265
文章目录尚学堂1到13章所有练习题答案详解B站网课链接第一章一、选择题三、上机操作第二章第三章第四章一、选择题二、简答题三：编程题第五章一、选择题第六章第七章一、 选择题二、 简答题第八章第九章第十章第十一章第十二章第十三章 尚学堂1到13章所有练习题答案详解 B站网课链接 配合网课食用学习效果更佳bilibili JAVA300集 尚学堂文档 第一章 一、选择题 以下（ C ）不是Java...
Java实现坦克大战，单机版和联网版
ojemmm的博客
12-13 1319
Java实现坦克大战源码获取途径部分源代码 源码获取途径 百度网盘链接： 百度网盘地址 提取码：z1gq GitHub Github获取地址 部分源代码 public class TankClient extends Frame{ //尺寸 public static final int W=800; public static final int H=600; //双缓存...
java视频 坦克大战制作
wind14的博客
01-13 2038
学习一门编程语言入门，什么方法比较快，那肯定是跟着老师一起来找一个项目入手了，下面是java  坦克大战制作视频链接地址，该视频报包裹了本地版坦克大战，局域网版坦克大战，网络版坦克大战，有需求的同学可以自行下载。 下面是视频的下载地址（百度云）： 链接: http://pan.baidu.com/s/1qWTlKN6 密码: c2ai
TankWar 单机（JAVA版）版本2.0.5 坦克撞墙的处理
苏苏爱自由
10-09 3402
首先附上运行结果： 从图中可以看完无论是我的坦克 还是敌方坦克都不能通过石头墙 土墙 水池。可以通过灌木丛 道理和子弹击中坦克一样。获取地图的矩形位置，坦克的矩形位置，判断两个矩形是否相交。如果相交再根据地形是否为灌木丛 等，让坦克回到移动前的位置。 首先在wall类中求出各种地形的宽和高 public void setWidthAndHeight(Image img) {
Java实现坦克大战（源码全）
O_C_E_A_N_的博客
04-05 1万+
开头 参考自尚学堂，后文代码CV并添加图片资源即可运行 对代码有一定的重构，功能的添加(按‘G’开挂) 评论区留联系方式（微信除外），看到后会发送图片资源。 项目结构 GamePanel KeyMonitor (内部类) keyPressed(KeyEvent): void keyReleased(KeyEvent): void launch(): void paint(Graphics): void main(String[]): void package com.company.tank; im
坦克大战java尚学堂
最新发布
05-10
坦克大战Java是尚学堂Java课程中的一个大型综合项目，其目的是通过实现一个完整的游戏项目，让学员深入理解Java面向对象的编程思想和基础语法，掌握Java SE开发基础，同时学习常用的设计模式和游戏开发的相关知识。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值