Java坦克大战代码

曾经终败给现在 2023-03-01 12:50 73阅读 0赞

上代码前的图片：（爆炸效果）  
![在这里插入图片描述][2020072610252737.gif]  
![在这里插入图片描述][20200726102543545.gif]  
![在这里插入图片描述][20200726102604663.gif]  
请按这三张图片的顺序插入

## 上代码！ ##

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;
    	}
    }

# 完结 #

[2020072610252737.gif]: /images/20230208/5b39e27127994dca8dd143f9592c4c3a.png
[20200726102543545.gif]: /images/20230208/24ae730d944f4a699b618eb6e9c3f2d9.png
[20200726102604663.gif]: /images/20230208/48afa8eb10d14961b3b5bffd51b40d7e.png