坦克大战0.8-1.4

最新推荐文章于 2022-08-03 02:12:06 发布

Slience_Perseverance

最新推荐文章于 2022-08-03 02:12:06 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏： java学习笔记文章标签： import class null thread image string

本文链接：https://blog.youkuaiyun.com/Slience_Perseverance/article/details/7772093

java学习笔记专栏收录该内容

25 篇文章

订阅专栏

本文详细介绍了一个简单的坦克大战游戏开发过程，包括坦克的八个方向移动、子弹发射及移动等功能的实现。通过逐步迭代版本，实现了从坦克移动到多发子弹射击的完整游戏逻辑。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

版本0.8：
功能：
让主坦克向8个方向行走
步骤：
添加记录按键状态的布尔量
添加代表方向的量（使用枚举）
根据按键状态确定Tank方向
根据方向进行下一步的移动（move）
版本0.9
功能：
让主坦克向8个方向行走
步骤：
处理键抬起的消息
修改TankClient相关代码
版本1.0
功能：
添加子弹类
步骤：
添加Missile类
添加x，y，dir等属性以及常量
添加构造方法、draw方法等必要方法
根据不同方向，进行不同的运动
在TankClient中模拟一颗子弹
new一颗子弹出来
画出来
注意：
不一定一次写到位
进行多次实验
将步骤分解开来逐一进行调试
版本1.1
功能：
根据主战坦克的方向和位置，打出子弹
步骤：
增加对Ctrl键的按键处理
根据“坦克打出一发子弹”这句话，来确定Tank中的
方法fire，其返回值为Missile
根据Tank方向和位置设定子弹的方向和位置并发射出来
注意：
掌握面向对象的思维方式来确定类应该具有的方法
版本1.2
功能：
为了解决坦克停下来也能打出炮弹的问题--画出炮筒
步骤：
Tank类增加新的属性ptDir
每次move后根据Tank新的方向确定炮筒的方向
将炮筒用直线的形式表现出来
版本1.3
功能：
打出多发炮弹
步骤：
使用容器装炮弹
每当抬起Ctrl键就往容器中加入新的炮弹
逐一画出每发炮弹
注意：
泛型的使用
将TankClient的实例传递到Tank中
this的运用，类的初始化过程
版本1.4
功能：
解决炮弹不消亡的问题
解决坦克出界的问题
步骤：
加入控制炮弹生死的量bLive（Missile）
当炮弹已经死去就不需要对其重画
当炮弹飞出边界就死亡
当炮弹死亡就从容器中去除
注意：

将思维转化为代码

import java.awt.*;
import java.awt.event.*;
import java.util.List;
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(50, 50, this);
	List<Missile> missiles = new ArrayList<Missile>();
	
	Image offScreenImage = null;
	
	public void paint(Graphics g) {
		g.drawString("missiles count:" + missiles.size(), 50, 50);
		for(int i=0;i<missiles.size();i++){
			Missile m = missiles.get(i);
			//if(!m.isLive())
				//missiles.remove(m);
			//else
				m.draw(g);
		}
		myTank.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.GREEN);
		gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
		gOffScreen.setColor(c);
		paint(gOffScreen);
		g.drawImage(offScreenImage, 0, 0, null);
	}

	public void lauchFrame() {
		this.setLocation(300, 50);
		this.setSize(GAME_WIDTH, GAME_HEIGHT);
		this.setTitle("TankWar");
		this.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		this.setResizable(false);
		this.setBackground(Color.GREEN);
		
		this.addKeyListener(new KeyMonitor());
		
		setVisible(true);
		
		new Thread(new PaintThread()).start();
	}

	public static void main(String[] args) {
		TankClient tc = new TankClient();
		tc.lauchFrame();
	}
	
	private class PaintThread 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);
		}
		
	}
}

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

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;
	
	TankClient tc = null;
	
	private int x, y;
	
	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) {
		this.x = x;
		this.y = y;
	}
	
	public Tank(int x, int y, TankClient tc) {
		this(x, y);
		this.tc = tc;
	}
	
	public void draw(Graphics g) {
		Color c = g.getColor();
		g.setColor(Color.RED);
		g.fillOval(x, y, WIDTH, HEIGHT);
		g.setColor(c);
		
		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() {
		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)
			ptDir = dir;
	}
	
	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_CONTROL:
			fire(); 
			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(){
		int x = this.x + Tank.WIDTH/2 - Missile.WIDTH;
		int y = this.y + Tank.HEIGHT/2 - Missile.HEIGHT;
		Missile m = new Missile(x , y, ptDir, this.tc);
		tc.missiles.add(m);
		return m;
	}
}

import java.awt.*;




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 Live = true;
	private TankClient tc;
	
	public boolean isLive() {
		return Live;
	}

	public Missile(int x, int y, Tank.Direction dir) {
		this.x = x;
		this.y = y;
		this.dir = dir;
	}
	public Missile(int x, int y, Tank.Direction dir, TankClient tc) {
		this(x, y, dir);
		this.tc = tc;
	}
	
	
	public void draw(Graphics g){
		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);
		}
	}

}