欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java坦克大战代码

程序员文章站 2022-06-19 09:17:24
上代码前的图片:(爆炸效果)请按这三张图片的顺序插入上代码!MyTankGame8.java/** * 功能:坦克游戏的7.0 * 1.画出坦克(√) * 2.我的坦克可以上下左右移动(√) * 3.可以连发子弹(最多5).(√) * 4.当我的坦克击中敌人的坦克时,敌人就消失(爆炸的效果)(√) * 5.我被击中后,显示爆炸效果(√) * 6.防止敌人坦克重叠运动(√) * 6.1.判断是否碰撞的函数写到EnemyTank类 * 7.可以分关(√) *...

上代码前的图片:(爆炸效果)
Java坦克大战代码
Java坦克大战代码
Java坦克大战代码
请按这三张图片的顺序插入

上代码!

MyTankGame8.java

/**
 * 功能:坦克游戏的7.0      
 * 1.画出坦克(√)
 * 2.我的坦克可以上下左右移动(√)
 * 3.可以连发子弹(最多5).(√)
 * 4.当我的坦克击中敌人的坦克时,敌人就消失(爆炸的效果)(√)
 * 5.我被击中后,显示爆炸效果(√)
 * 6.防止敌人坦克重叠运动(√)
 *   6.1.判断是否碰撞的函数写到EnemyTank类
 * 7.可以分关(√)
 *   7.1.做一个开始的Panel,他是一个空的
 *   7.2.闪烁效果
 * 8.可以在玩游戏的时候暂停和继续(√)
 *   8.1.暂停的时候,坦克和子弹速度为0,并且坦克方向不变
 * 9.可以记录玩家的成绩(√)
 * 	 9.1.用文件流
 *   9.2.单写一个纪录类,完成玩家记录
 *   9.3.先完成保存共击毁了多少辆敌人的坦克的功能
 *   9.4.存盘退出游戏,可以记录当时的敌人的坦克的坐标,并可以修复
 * 10.java如何操作声音文件(√)
 */
package lesson_49;

import java.awt.*;       
import javax.swing.*;
import java.awt.event.*;
import java.util.*;
import javax.imageio.*;
import java.io.*;
@SuppressWarnings({"serial","unused"})
public class MyTankGame8 extends JFrame implements ActionListener {

	MyPanel mp =null;
	
	//定义一个开始面板
	MyStartPanel msp =null;
	
	//做出我需要的菜单
	JMenuBar jmb =null;
	
	//开始游戏
	JMenu jm1 =null;
	JMenuItem jmi1 =null;
	
	//退出系统
	JMenuItem jmi2 =null;
	
	//存盘退出
	JMenuItem jmi3 =null;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		MyTankGame8 mtg =new MyTankGame8();
	}
	
	//构造函数
	public MyTankGame8()
	{		
		//创建菜单及菜单选项
		jmb =new JMenuBar();
		jm1 =new JMenu("游戏(G)");
		jmi1 =new JMenuItem("开始新游戏(N)");
		jmi2 =new JMenuItem("退出游戏(E)");
		jmi3 =new JMenuItem("存盘退出游戏(C)");
		
		jm1.add(jmi1);
		jm1.add(jmi2);
		jm1.add(jmi3);
		
		jmb.add(jm1);
		
		//设置快捷方式
		jm1.setMnemonic('G');
		jmi1.setMnemonic('N');
		jmi2.setMnemonic('E');
		jmi3.setMnemonic('C');
		
		//对jmi响应
		jmi1.addActionListener(this);
		jmi1.setActionCommand("newgame");
		jmi2.addActionListener(this);
		jmi2.setActionCommand("exit");
		jmi3.addActionListener(this);
		jmi3.setActionCommand("saveExit");
		
		msp =new MyStartPanel();
		this.add(msp);
		
		Thread th =new Thread(msp);
		th.start();
			
		this.setJMenuBar(jmb);
		this.setSize(600,500);
		this.setVisible(true);
		this.setTitle("坦克大战");
		this.setResizable(false);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}

	public void actionPerformed(ActionEvent e) 
	{
		//对用户不同的点击做出不同的管理
		if(e.getActionCommand().equals("newgame"))
		{
			mp =new MyPanel();
			//jp1 =new JPanel();
			
			//删除老的面板
			this.remove(msp);
			
			this.add(mp);
				
			//注册监听
			this.addKeyListener(mp);
			
			//启动mp线程
			Thread t =new Thread(mp);
			t.start();
			this.setVisible(true);
		}else if(e.getActionCommand().equals("exit"))
		{
			//用户点击了退出系统的菜单
			//保存击毁敌人数量
			Recorder.keepRecording();
			
			System.exit(0);
		}else if(e.getActionCommand().equals("saveExit"))
		{
			//工作
			new Recorder().setEts(mp.ets);
			
			//保存击毁敌人的数量和敌人的坐标
			new Recorder().keepRecAndEnemyTank();
			
			//退出
			System.exit(0);
		}
	}
}

@SuppressWarnings({"serial"})
//就是一个提示的作用
class MyStartPanel extends JPanel implements Runnable
{
	int times =0;
	
	public void paint(Graphics g)
	{
		super.paint(g);
		
		g.fillRect(0,0,416,339);
		
		if(times%2==0)
		{
			g.setColor(Color.YELLOW);
			//开关信息的字体
			Font myFont =new Font("微软雅黑",Font.BOLD,30);
			g.setFont(myFont);
			
			//提示信息
			g.drawString("stage:1",150,150);
		}
	}

	public void run() 
	{
		while(true)
		{
			//休眠
			try {
				Thread.sleep(500);
			}catch (InterruptedException e){
				e.printStackTrace();
			}
			
			times++;
			
			this.repaint();
		}
	}
}

//我的面板
@SuppressWarnings({"serial"})
class MyPanel extends JPanel implements KeyListener,Runnable
{
	//定义一个我的坦克
	Hero hero =null;
	
	//定义敌人的坦克组
	Vector<EnemyTank> ets =new Vector<EnemyTank>();
	
	//定义炸弹
	Vector<Bomb> bombs =new Vector<Bomb>();
	
	int enSize=3;
	
	//定义三张图片,三张图片才能组成一颗炸弹
	Image image1 =null;
	Image image2 =null;
	Image image3 =null;
	
	//构造函数
	public MyPanel()
	{
		//恢复记录
		Recorder.getRecoring();
		
		hero =new Hero(100,100);
		
		//初始化敌人的坦克
		for(int i=0;i<enSize;i++)
		{
			//创建一辆敌人的坦克对象
			EnemyTank et =new EnemyTank((i+1)*50,0);
			
			et.setColor(0);
			et.setDirect(2);
			
			//将MyPanel的敌人坦克向量交给该敌人坦克
			et.setEts(ets);
			
			//启动敌人的坦克
			Thread t =new Thread(et);
			t.start();
			
			//给敌人坦克添加子弹
			Shot s =new Shot(et.x+10,et.y+30,2);
			
			//把子弹给敌人
			et.ss.add(s);
			
			Thread t2 =new Thread(s);
			t2.start();
			
			//加入
			ets.add(et);
		}
		
		try{
			image1 =ImageIO.read(new File("bemb_1.gif"));
			image2 =ImageIO.read(new File("bemb_2.gif"));
			image3 =ImageIO.read(new File("bemb_3.gif"));
		}catch(Exception e){
			e.printStackTrace();
		}
		
		//初始化图片
//		image1 =Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bemb_1.gif"));
//		image2 =Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bemb_2.gif"));
//		image3 =Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/bemb_3.gif"));
	}
	
	//画出提示信息
	public void showInfo(Graphics g)
	{	
		//画出提示信息坦克(该坦克不参与战斗)
		this.drawTank(80,330,g,0,0);
		g.setColor(Color.BLACK);
		g.drawString(Recorder.getEnNum()-3+"",105,350);
		this.drawTank(150,330,g,0,1);
		g.setColor(Color.BLACK);
		g.drawString(Recorder.getMyLife()+"",175,350);
		
		//画出玩家的总成绩
		Font f =new Font("宋体",Font.BOLD,20);
		
		g.setFont(f);
		g.setColor(Color.BLACK);
		g.drawString("您的总成绩",420,30);
	
		this.drawTank(420,60,g,0,0);
	
		g.setColor(Color.BLACK);
		g.drawString(Recorder.getAllEnNum()+"",455,80);
	}
	
	//重新paint
	public void paint(Graphics g)
	{
		super.paint(g);
		g.setColor(Color.BLACK);
		g.fillRect(0,0,400,300);
		
		//画出提示信息
		this.showInfo(g);
		
		//画出自己的坦克
		if(hero.isLive)
		{
			this.drawTank(hero.getX(),hero.getY(),g,this.hero.direct,1);
		}
		
		//从ss中取出每颗子弹,并画出
		for(int i=0;i<hero.ss.size();i++)
		{
			Shot myShot =hero.ss.get(i);
			
			//画出子弹,
			if(myShot!=null&&myShot.isLive==true)
			{
				g.draw3DRect(myShot.x,myShot.y,1,1,false);
			}
			if(myShot.isLive==false)
			{
				//从ss中删除掉该子弹
				hero.ss.remove(myShot);
			}
		}
		
		//画出炸弹
		for(int i=0;i<bombs.size();i++)
		{
			//System.out.println("bombs.size()="+bombs.size());
			//取出炸弹
			Bomb b =bombs.get(i);
			
			if(b.life>6){
				g.drawImage(image1,b.x,b.y,30,30,this);
			}else if(b.life>3){
				g.drawImage(image2,b.x,b.y,30,30,this);
			}else{
				g.drawImage(image3,b.x,b.y,30,30,this);
			}
			
			//让b的生命减小
			b.lifeDown();
			
			//如果炸弹生命值为0,就把该炸弹从bombs去掉
			if(b.life==0)
			{
				bombs.remove(b);
			}
		}
		
		//画出敌人坦克
		for(int i=0;i<ets.size();i++)
		{
			EnemyTank et =ets.get(i);
			
			if(et.isLive)
			{
				this.drawTank(et.getX(),et.getY(),g,et.getDirect(),0);
			
				//在画出敌人的子弹
				for(int j=0;j<et.ss.size();j++)
				{
					//取出一个子弹
					Shot enemyTank =et.ss.get(j);
					
					if(enemyTank.isLive)
					{
						g.draw3DRect(enemyTank.x,enemyTank.y,1,1,false);
					}else{
						//如果敌人的坦克死亡就从Vector中删掉
						et.ss.remove(enemyTank);
					}
				}
			}
		}
	}
	
	//敌人的子弹是否击中我
	public void hieMe()
	{
		//取出每一个敌人的坦克
		for(int i=0;i<ets.size();i++)
		{
			//取出坦克
			EnemyTank et =ets.get(i);
			
			//取出每一颗子弹
			for(int j=0;j<et.ss.size();j++)
			{
				//取出子弹
				Shot enemyShot =et.ss.get(j);
				
				if(hero.isLive)
				{
					if(this.hitTank(enemyShot,hero))
					{
						//Recorder.reduceEnNum();
						//Recorder.addEnNumRec();
					}
				}
			}
		}
	}
	
	//判断我的坦克是否击中敌人的坦克
	public void hitEnemyTank()
	{
		for(int i=0;i<hero.ss.size();i++)
		{
			//取出子弹
			Shot myShot =hero.ss.get(i);
		
			//判断子弹是否有效
			if(myShot.isLive)
			{
				//取出每一个子弹,与他判断
				for(int j=0;j<ets.size();j++)
				{
					//取出坦克
					EnemyTank et =ets.get(j);
					
					if(et.isLive)
					{
						if(this.hitTank(myShot,et))
						{
							Recorder.reduceEnNum();
							Recorder.addEnNumRec();
						}
					}
				}
			}
		}
	}

	//写一个函数,专门判断子弹是否击中敌人坦克
	public boolean hitTank(Shot s,Tank et)
	{
		boolean b2 =false;
		
		//判断该坦克的方向
		switch(et.direct)
		{
			//如果敌人的坦克方向是上或下
			case 0:
			case 2:
				if(s.x>et.x&&s.x<et.x+20&&s.y>et.y&&s.y<et.y+30)
				{
					//击中
					//子弹死亡
					s.isLive=false;
					
					//敌人坦克死亡
					et.isLive=false;
					
					b2=true;
					
					//创建一颗炸弹,放入Vector
					Bomb b =new Bomb(et.x,et.y);
					
					//放入Vector
					bombs.add(b);
				}
				break;
			case 1:
			case 3:
				if(s.x>et.x&&s.x<et.x+30&&s.y>et.y&&s.y<et.y+20)
				{
					//击中
					//子弹死亡
					s.isLive=false;
					
					//敌人坦克死亡
					et.isLive=false;
					
					b2=true;
					
					//创建一颗炸弹,放入Vector
					Bomb b =new Bomb(et.x,et.y);
					
					//放入Vector
					bombs.add(b);
				}
				break;
		}
		
		return b2;
	}
	
	//画出坦克的函数(扩展)
	public void drawTank(int x,int y,Graphics g,int direct,int type)
	{
		//判断是什么坦克
		switch(type)
		{
			case 0:
				g.setColor(Color.CYAN);
				break;
			case 1:
				g.setColor(Color.YELLOW);
				break;
		}
		
		//判断方向
		switch(direct)
		{
			//向上
		    case 0:
		    	//画出我的坦克(到时在封装成函数)
				//1.画出左边的矩形
				g.fill3DRect(x,y,5,30,false);
			
				//2.画出右边的矩形
				g.fill3DRect(x+15,y,5,30,false);
			
				//3.画出中间矩形
				g.fill3DRect(x+5,y+5,10,20,false);
			
				//4.画出圆形
				g.fillOval(x+5,y+10,10,10);
				
				//5.画出线
				g.drawLine(x+10,y+15,x+10,y);
				break;
		    case 1:
		    	//炮筒向右
		    	//画出上面的矩形
		    	g.fill3DRect(x,y,30,5,false);
		    	
		    	//画出下面的矩形
		    	g.fill3DRect(x,y+15,30,5,false);
		    	
		    	//画出中间的矩形
		    	g.fill3DRect(x+5,y+5,20,10,false);
		    	
		    	//画出圆形
		    	g.fillOval(x+10,y+5,10,10);
		    	
		    	//画出线
		    	g.drawLine(x+15,y+10,x+30,y+10);
		    	break;
		    case 2:
		    	//向下
				//1.画出左边的矩形
				g.fill3DRect(x,y,5,30,false);
			
				//2.画出右边的矩形
				g.fill3DRect(x+15,y,5,30,false);
			
				//3.画出中间矩形
				g.fill3DRect(x+5,y+5,10,20,false);
			
				//4.画出圆形
				g.fillOval(x+5,y+10,10,10);
				
				//5.画出线
				g.drawLine(x+10,y+15,x+10,y+30);
		    	break;
		    case 3:
		    	//向左
				//1.画出左边的矩形
				g.fill3DRect(x,y,30,5,false);
			
				//2.画出右边的矩形
				g.fill3DRect(x,y+15,30,5,false);
			
				//3.画出中间矩形
				g.fill3DRect(x+5,y+5,20,10,false);
			
				//4.画出圆形
				g.fillOval(x+10,y+5,10,10);
				
				//5.画出线
				g.drawLine(x+15,y+10,x,y+10);
		    	break;
		}
	}

	//键按下 a表示向左,s表示向下,w表示向上,d表示向右
	public void keyPressed(KeyEvent e) 
	{
		if(e.getKeyCode()==KeyEvent.VK_W)
		{
			//设置我的坦克的方向
			this.hero.setDirect(0);
			this.hero.moveUp();
		}else if(e.getKeyCode()==KeyEvent.VK_D)
		{
			//向右
			this.hero.setDirect(1);
			this.hero.moveRight();
		}else if(e.getKeyCode()==KeyEvent.VK_S)
		{
			//向下
			this.hero.setDirect(2);
			this.hero.moveDown();
		}else if(e.getKeyCode()==KeyEvent.VK_A)
		{
			//向左
			this.hero.setDirect(3);
			this.hero.moveLeft();
		}
		
		//判断玩家是否按下j键
		if(e.getKeyCode()==KeyEvent.VK_J)
		{
			//开火
			if(this.hero.ss.size()<=4)
			{
				this.hero.shotEnemy();	
			}
		}
		
		//必须重绘MyPanel
		this.repaint();
	}
	
	public void keyReleased(KeyEvent e) {
		
	}
	
	public void keyTyped(KeyEvent e) {
		
	}
	
	public void run()
	{
		//每隔一百毫秒刷新一次
		while(true)
		{
			try{
				Thread.sleep(100);
			}catch(Exception e){
				e.printStackTrace();
			}
			
			this.hitEnemyTank();
			
			//判断敌人的坦克有没有击中我的坦克
			this.hieMe();
			
			//重绘
			repaint();
		}
	}
}

Members.java

package lesson_49;

import java.util.*;
import java.io.*;
//纪录类,同时也可以保存玩家的
class Recorder
{
	//记录每关有多少个敌人
	private static int enNum=23;
	
	//设置我有多少可用的人
	private static int myLife=3;
	
	//记录总共消灭了多少辆坦克
	private static int allEnNum=0;
	
	private static FileWriter fw =null;
	private static BufferedWriter bw =null;
	private static FileReader fr =null;
	private static BufferedReader br =null;
	private Vector<EnemyTank> ets = new Vector<EnemyTank>();
	
	//保存击毁敌人的数量和敌人坦克坐标,方向
	public void keepRecAndEnemyTank()
	{
		try{
			fw =new FileWriter("d:\\myRecording1.txt");
			bw =new BufferedWriter(fw);
			
			bw.write(allEnNum+"\r\n");
			
			//保存当前活的敌人坦克的坐标和方向
			for(int i=0;i<ets.size();i++)
			{
				//取出第一个坦克
				EnemyTank et =ets.get(i);
				
				if(et.isLive)
				{
					//活的就保存
					String recode =et.x+" "+et.y+" "+et.direct;
				
					//写入
					bw.write(recode+"\r\n");
				}
			}
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				bw.close();
				fw.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	//从文件中读取,记录
	public static void getRecoring()
	{
		try{
			fr =new FileReader("d:\\myRecording.txt");
			br =new BufferedReader(fr);
			String n =br.readLine();
			allEnNum =Integer.parseInt(n);
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				br.close();
				fr.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	//把玩家击毁敌人坦克数量保存到文件中
	public static void keepRecording() 
	{
		try{
			fw =new FileWriter("d:\\myRecording.txt");
			bw =new BufferedWriter(fw);
			
			bw.write(allEnNum+"\r\n");
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			try{
				bw.close();
				fw.close();
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
	
	public static int getAllEnNum() {
		return allEnNum;
	}

	public static void setAllEnNum(int allEnNum) {
		Recorder.allEnNum = allEnNum;
	}

	public static int getEnNum() {
		return enNum;
	}

	public static void setEnNum(int enNum) {
		Recorder.enNum = enNum;
	}

	public static int getMyLife() {
		return myLife;
	}

	public static void setMyLife(int myLife) {
		Recorder.myLife = myLife;
	}
	
	//减少敌人数量
	public static void reduceEnNum()
	{
		enNum--;
	}
	
	//消灭敌人
	public static void addEnNumRec()
	{
		allEnNum++;
	}
	
	public Vector<EnemyTank> getEts()
	{
		return ets;
	}
	
	public void setEts(Vector<EnemyTank> ets1)
	{
		//this.ets =ets;
		System.out.println("ok");
	}
}

//炸弹类
class Bomb
{
	//定义炸弹的坐标
	int x,y;
	
	//炸弹的生命
	int life=9;
	
	boolean isLive=true;
	
	public Bomb(int x,int y)
	{
		this.x=x;
		this.y=y;
	}
	
	//减少生命
	public void lifeDown()
	{
		if(life>0)
		{
			life--;
		}else{
			this.isLive=false;
		}
	}
}

//子弹类
class Shot implements Runnable
{
	int x;
	int y;
	int direct;
	int speed=1;
	
	//是否还活着
	boolean isLive =true;
	
	public Shot(int x,int y,int direct)
	{
		this.x=x;
		this.y=y;
		this.direct=direct;
	}
	
	public void run()
	{	
		while(true)
		{
			try
			{
				Thread.sleep(50);
			}catch(Exception e){
				e.printStackTrace();
			}
			
			switch(direct)
			{
				case 0:
					//向上
					y-=speed;
					break;
				case 1:
					//左
					x+=speed;
					break;
				case 2:
					//下
					y+=speed;
					break;
				case 3:
					//右
					x-=speed;
					break;
			}
				
			//子弹何时死亡[???思考题???]
			//判断该子弹是否碰到边缘
			if(x<0||x>400||y<0||y>300)
			{
				this.isLive=false;
				break;
			}
		}
	}
}

//坦克类
class Tank
{
	//表示坦克的横坐标
	int x=0;
	
	//坦克纵坐标
	int y=0;
	
	//坦克方向
	//0表示上,1表示右,2表示下,3表示左
	int direct=0;
	int color;
	
	boolean isLive =true;
	
	public int getColor() {
		return color;
	}

	public void setColor(int color) {
		this.color = color;
	}

	//坦克的速度
	int speed=1;
	
	public int getSpeed() {
		return speed;
	}

	public void setSpeed(int speed) {
		this.speed = speed;
	}

	public int getDirect() {
		return direct;
	}

	public void setDirect(int direct) {
		this.direct = direct;
	}

	public int getX() {
		return x;
	}

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

	public int getY() {
		return y;
	}

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

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

//敌人的坦克,把敌人做成线程类
class EnemyTank extends Tank implements Runnable 
{
	//boolean isLive=true;
	
	//定义一个向量,可以访问到MyPanel上所有敌人的坦克
	Vector<EnemyTank> ets =new Vector<EnemyTank>(); 
	
	//定义一个向量,可以存放敌人的子弹
	Vector<Shot> ss =new Vector<Shot>();
	
	//敌人添加子弹,应当在刚刚创建的坦克和敌人的坦克死亡的过后
	
	int times =0;
	
	public EnemyTank(int x,int y)
	{
		super(x,y);
	}
	
	//得到MyPanel的敌人坦克向量
	public void setEts(Vector<EnemyTank> vv)
	{
		this.ets=vv;
		//isTouchOtherEnemy();
	}
	
	//判断是否碰到了别的敌人坦克
	public boolean isTouchOtherEnemy()
	{
		boolean b=false;
		
		switch(this.direct)
		{
			case 0:
				//我的坦克在上
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<et.x+20&&this.y>=et.y&&this.y<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x>=et.x&&this.x<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
						}
					}
				}
				break;
			case 1:
				//我的坦克在右
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x+30>=et.x&&this.x+30<=et.x+20&&this.y>=et.y&&this.y<=et.y+30)
							{
								return true;
							}
							
							if(this.x+30>=et.x&&this.x+30<=et.x+20&&this.y+20>=et.y&&this.y+20<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x+30>=et.x&&this.x+30<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
							
							if(this.x+30>=et.x&&this.x+30<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
							{
								return true;
							}
						}
					}
				}
				break;
			case 2:
				//我的坦克在下
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x>=et.x&&this.x<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<=et.x+20&&this.y+30>=et.y&&this.y+30<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x>=et.x&&this.x<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+20)
							{
								return true;
							}
							
							if(this.x+20>=et.x&&this.x+20<=et.x+30&&this.y+30>=et.y&&this.y+30<=et.y+20)
							{
								return true;
							}
						}
					}
				} 
				break;
			case 3:
				//我的敌人坦克向左  
				//取出所有敌人的坦克
				for(int i=0;i<ets.size();i++)
				{
					//取出第一个坦克
					EnemyTank et =ets.get(i);
					
					//如果不是自己
					if(et!=this)
					{
						//如果敌人的方向是向下或向上
						if(et.direct==0||et.direct==2)
						{
							if(this.x>=et.x&&this.x<=et.x+20&&this.y>=et.y&&this.y+30<=et.y+30)
							{
								return true;
							}
							
							if(this.x>=et.x&&this.x<=et.x+20&&this.y+20>=et.y&&this.y+20<=et.y+30)
							{
								return true;
							}
						}
						
						//向左或向右
						if(et.direct==3||et.direct==1)
						{
							if(this.x>=et.x&&this.x<=et.x+30&&this.y>=et.y&&this.y<=et.y+20)
							{
								return true;
							}
							
							if(this.x>=et.x&&this.x<=et.x+30&&this.y+20>=et.y&&this.y+20<=et.y+20)
							{
								return true;
							}
						}
					}
				}
				break;
		}
		
		return b;
	}
	
	public void run()
	{
		while(true)
		{
			try{
				Thread.sleep(50);
			}catch(Exception e){
				e.printStackTrace();
			}
			
			switch(this.direct)
			{
				case 0:
					//说明坦克正在向上
					for(int i=0;i<30;i++)
					{
						if(y>0&&!this.isTouchOtherEnemy())
						{
							y-=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
				case 1:
					//向右
					for(int i=0;i<30;i++)
					{
						//保证坦克不出边界
						if(x<400&&!this.isTouchOtherEnemy())
						{
							x+=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
				case 2:
					//向下
					for(int i=0;i<30;i++)
					{
						if(y<300&&!this.isTouchOtherEnemy())
						{
							y+=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
				case 3:
					//向左
					for(int i=0;i<30;i++)
					{
						if(x>0&&!this.isTouchOtherEnemy())
						{
							x-=speed;
						}
						
						try{
							Thread.sleep(50);
						}catch(Exception e){
							e.printStackTrace();
						}
					}
					break;
			}
			
			this.times++;
			
			if(times%2==0)
			{
				if(isLive)
				{
					if(ss.size()<5)
					{
						Shot s =null;
						
						switch(direct)
						{
							case 0:
								s =new Shot(x+10,y,0);
								ss.add(s);
								break;
							case 1:
								s =new Shot(x+30,y+10,1);
								ss.add(s);
								break;
							case 2:
								s =new Shot(x+10,y+30,2);
								ss.add(s);
								break;
							case 3:
								s =new Shot(x+10,y+10,3);
								ss.add(s);
								break;
						}
						
						Thread t =new Thread(s);
						t.start();
					}
				}
			}
			
			//让坦克随机长生一个新的方向
			this.direct=(int)(Math.random()*4);
			
			//判断敌人坦克是否死亡
			if(this.isLive==false)
			{
				//让坦克死亡后,退出线程
				break;
			}
		}
	}
}

//定义我的坦克
class Hero extends Tank
{	
	//子弹
	//Shot s=null;
	Vector<Shot>ss =new Vector<Shot>();
	Shot s =null;
	
	public Hero(int x,int y)
	{
		super(x,y);
		
	}
	
	//开火
	public void shotEnemy()
	{
		switch(this.direct)
		{
			case 0:
				//创建一颗子弹
				s =new Shot(x+10,y,0);
				
				//把子弹加入变量
				ss.add(s);
				break;
			case 1:
				//创建一颗子弹
				s =new Shot(x+30,y+10,1);
				ss.add(s);
				break;
			case 2:
				//创建一颗子弹
				s =new Shot(x+10,y+30,2);
				ss.add(s);
				break;
			case 3:
				//创建一颗子弹
				s =new Shot(x,y+10,3);
				ss.add(s);
				break;
		}
		
		//启动子弹线程
		Thread t =new Thread(s);
		t.start();
	}
	
	//坦克向上移动
	public void moveUp()
	{
		y-=speed;
	}
	
	//坦克向右移动
	public void moveRight()
	{
		x+=speed;
	}
	
	//坦克向下移动
	public void moveDown()
	{
		y+=speed;
	}
	
	//坦克向左移动
	public void moveLeft()
	{
		x-=speed;
	}
}

完结

本文地址:https://blog.csdn.net/weixin_45445598/article/details/107590035