Java语言坦克大战游戏设计(附有代码和图片)

合集下载

Java综合编程——坦克大战(15.1.5)

子弹类中的run()方法中
ActionEvent e
实现事件监听三步：
1. 2. 3.
确定事件源确定监听类监听对象的注册
举例——练习1

1. 2.tton，当该按钮被按下后，系统给出提示事件源JButton对象监听器：
单独创建一个类负责监听让JFrame负责监听
3.
把监听器加入到事件源中（注册监听） *事件对象，系统自动产生

坦克有方向，画出所有方向的坦克
3、形成Tank类的子类

敌人坦克（EnemyTank）和我方坦克 (MyTank) 在这两个方法中覆盖父类的构造方法将敌人坦克的颜色设置成蓝色我方坦克设置成红色
4、

在MyPanel中绘制出一辆我方坦克，方向向上绘制出五辆敌人坦克，方向向下
在paint方法中用System.out.println(“调用 paint");

画直线：g.drawLine(10, 10, 40, 40); 画矩形边框：g.drawRect(60, 60, 100, 200); 画填充矩形：g.fill3DRect(50, 50, 30, 30, true); 设置颜色：g.setColor(Color.red);
基础知识
1. 2.
图形用户界面 Java绘图技术
1、图形用户界面

创建一个用户界面JFrame，取名为MainFrame 在其上添加一个JPanel，显示一个圆。
编程思路

（构建坦克大战主窗口）

坦克大战的主窗口是由一个JFrame构成的，因为需要在上面作图，但是JFrame没有这个功能，所以我们要在JFrame上再加上一个JPanel，在 JPanel上绘图。我们在这里没有直接用JFrame和JPanel类，而是定义另外两个类MainFrame和MainPanel,这个两个类分别继承了JFrame和JPanel，然后再由这两个类分别生成对象mf和mp,我们要在mp 对象上作图

韩顺平java坦克大战1.0版本_源代码

/＊*画坦克1。

0＊/import java.awt.Color;import java.awt.Graphics；import java.awt.event。

KeyEvent;import java.awt。

event。

KeyListener；import java。

awt。

event.MouseEvent；import java。

awt。

event。

MouseListener;import java。

awt。

event.MouseMotionListener;import java.awt。

event。

WindowEvent；import java.awt。

event。

WindowListener;import javax。

swing。

JFrame;import javax.swing。

JPanel；public class MyTankGame extends JFrame｛MyPanel mp=null；public static void main（String［] args)｛MyTankGame mtk=new MyTankGame（）；｝public MyTankGame（）｛mp=new MyPanel（）；this.add（mp）；//把面板加入窗体//注册监听this。

addMouseListener（mp）；this.addKeyListener（mp）;this。

addMouseMotionListener(mp）；this.addWindowListener（mp）；this.setTitle(”坦克大战"）;//窗体标题this。

setSize(600，400)；//大小，宽,高(像素）this。

setLocation(300,300）;//显示位置。

左边距，上边距//禁止用户改变窗口大小this。

setResizable(false)；this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE）；this.setVisible（true）；//显示}}//我的面板class MyPanel extends JPanel implements WindowListener,MouseListener,MouseMotionListener，KeyListener{//定义一个我的坦克Hero hero=null；Diren diren=null；public MyPanel（){hero=new Hero(300，200）;diren=new Diren(100，0)；//diren。

Java语言坦克大战游戏设计附有代码和图片

JISHOU UNIVERSITY本科生毕业设计题目：基于java语言坦克大战游戏开发作者：学号：所属学院：信息科学与工程学院专业年级：指导教师：职称：完成时间：吉首大学教务处制目录基于java语言坦克大战游戏开发 (1)摘要 (1)Based on the development of Java language Tank Wars Game (2)第一章游戏简要说明 (3)第二章开发环境介绍 (4)2.1 开发环境 (4)2.2 java语言特点简介 (4)2.3 Eclipse开发工具的简介 (5)第三章系统总体设计 (6)3.1程序功能的总和 (6)3.2主体模块 (6)3.3子弹模块 (6)3.4坦克模块 (7)3.5 墙模块 (7)3.6血液模块 (7)3.7爆炸模块 (8)第四章游戏详细设计过程 (9)4.1创建游戏窗口 (9)4.2改变游戏背景颜色。

(11)4.3创建坦克 (11)4.4 让坦克动起来 (12)4.5改变窗口的大小 (13)4.6让坦克受控制 (14)4.7创建一个Tank类 (15)4.8让坦克向8个方向移动 (16)4.9修改4.8中所设计的不足 (18)4.10添加子弹类 (19)4.11根据己方坦克的位置，打出子弹 (21)4.12修改坦克停下来不能打出子弹的问题 (21)4.13让坦克能够打出多发子弹 (23)4.14解决炮弹不消亡和坦克出界的问题 (23)4.15增加敌方坦克 (24)4.16击毙出现的敌方坦克 (25)4.17加入爆炸效果 (26)4.18添加多辆敌方坦克 (27)4.19让敌方坦克智能化 (29)4.20建立游戏障碍物 (31)4.21阻止坦克互相穿越 (32)4.22为我方坦克添加大招和血条 (33)4.23添加血块 (34)4.24重新载入敌军或我军坦克 (35)4.25加入图片 (35)第五章游戏的可行性测试 (37)5.1游戏界面介绍 (37)5.2游戏运行测试 (40)第六章总结 (43)参考文献 (44)基于java语言坦克大战游戏开发摘要随着网络科技的不断发展，我们的生活出现了日新月异的变化，特别是在游戏这一块，出现了前所未有的繁荣，各种各样的游戏进入我们的生活，而当初的“俄罗斯方块”、“坦克大战”、“贪吃蛇”等这些经典中的经典的游戏曾被多少人所知，更是多少80后甚至90后常聊的话题。

JAVA课程设计坦克大战

得分显示：在游戏界面实时显示得分情况，方便玩家了解游戏进度
减少内存占用：优化数据结构，减少不必要的内存分配
提高渲染效率：优化渲染算法，减少渲染时间
优化网络通信：减少网络延迟，提高网络通信效率
优化AI算法：提高 AI算法的效率和准确性，提高游戏体验
界面布局：合理规划界面布局，提高用户
玩家需要控制坦克，消灭敌人，保护自己的基地
游戏支持多人在线对战，玩家可以与朋友一起挑战
玩家控制坦克，在战场上与敌人战斗
坦克可以发射炮弹，摧毁敌人或障碍物
玩家需要躲避敌人的攻击，保护自己的坦克
游戏有各种关卡，难度逐渐增加
玩家可以通过升级坦克，提高战斗力
游戏支持多人在线对战，增加游戏乐趣
生命值耗尽：当玩家的生命值降至0时，游戏结束
时间耗尽：当游戏时间耗尽时，游戏结束
胜利条件：当玩家达到胜利条件时，游戏结束
失败条件：当玩家达到失败条件时，游戏结束
得分规则：击毁敌方坦克得分，被敌方坦克击毁扣分
得分方式：根据击毁敌方坦克的数量和难度计算得分
得分限制：得分上限为1000分，达到上限后不再增加得分
,a click to unlimited possibilities
汇报人：
01
02
03
04
05
06
游戏类型：坦克大战
游戏背景：二战时期
游戏目标：摧毁敌方坦克，保护自己的基地
游戏玩法：玩家控制坦克，通过射击和躲避来消灭敌方坦克
游戏包含多个关卡，每个关卡有不同的难度和挑战
设计一款坦克大战游戏
游戏界面：包括菜单、地图、角色、道具等元素

JAVA课程设计坦克大战含代码

游戏结束判断
生命值耗尽：当坦克的生命值降至0时，游戏结束游戏时间结束：当游戏时间达到预设值时，游戏结束胜利条件达成：当一方达到预设的胜利条件时，游戏结束玩家主动退出：当玩家主动选择退出游戏时，游戏结束
游戏得分计算
得分规则：击毁敌方坦克、保护己方坦克、完成特定任务等
得分方式：根据击毁敌方坦克的数量、保护己方坦克的数量、完成任务的难度等计算得分
得分显示：在游戏界面实时显示得分情况，方便玩家了解游戏进度
得分记录：游戏结束后，记录玩家的分情况，方便玩家查看历史成绩
游戏优化与扩展
游戏性能优化
优化算法：使用更高效的算法，如动态规划、贪心算法等
减少内存占用：优化数据结构，减少不必要的内存占用
优化渲染：使用更高效的渲染技术，如 OpenGL、 DirectX 等
优化网络传输：使用更高效的网络传输协议，如TCP、 UDP等
优化AI：使用更高效的AI算法，如神经网络、遗传算法等
优化资源管理：合理分配系统资源，避免资源浪费
游戏扩展功能实现
增加新的坦克类型：如重型坦克、轻型坦克等
增加新的地图：如沙漠地图、雪地地图等
增加新的游戏模式：如团队模式、生存模式等
音效类型：背景音乐、战斗音效、胜利音效等
音效处理：音量调节、音效混合、音效剪辑等
添加标题
添加标题
添加标题
添加标题
音效来源：自行创作、购买版权、网络下载等
音效与游戏场景的结合：根据游戏场景选择合适的音效，增强游戏体验
游戏实体设计
坦克类设计
坦克属性：生命值、攻击力、防御力、速度等

Java游戏开发之坦克大战代码

Java游戏开发之坦克大战代码标题：Java游戏开发之坦克大战代码关键词：Java坦克大战,坦克大战Java代码这是一个Java坦克大战的源码，实现了大部分功能，是学习Java绘图技术的好例子主类：package com.qq.TankGame;import java.awt.Color;import java.awt.Font;import java.awt.Graphics;import java.awt.Image;import java.awt.Paint;import java.awt.Panel;import java.awt.Toolkit;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.KeyEvent;import java.awt.event.KeyListener;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.util.Vector;import javax.swing.JFrame;import javax.swing.JMenu;import javax.swing.JMenuBar;import javax.swing.JMenuItem;import javax.swing.JPanel;import javax.swing.JTextArea;/////**// * 功能：java绘图// * @author Administrator// *// */public class TankGame extends JFrame implements ActionListener{MyPanel mp = null;myStartPanel msp = null;EnemyTask em = null;JMenuBar jmb = null;JMenu jm = null;JMenuItem jmi1 = null;JMenuItem jmi2 = null;JMenuItem jmi3 = null;public static void main(String[] args) {TankGame tankGame = new TankGame();}public TankGame(){jmb = new JMenuBar();jm = new JMenu("游戏(G)");jm.setMnemonic('G');jmi1 = new JMenuItem("开始游戏(S)");jmi1.setMnemonic('S');jmi1.addActionListener(this);jmi1.setActionCommand("newGame");jmi2 = new JMenuItem("继续游戏(O)");jmi2.setMnemonic('O');jmi3 = new JMenuItem("退出游戏(X)");jmi3.setMnemonic('X');jmi3.addActionListener(this);jmi3.setActionCommand("exit");//启动mp线程//em = new EnemyTask();//mp = new MyPanel();msp = new myStartPanel();this.setJMenuBar(jmb);this.add(msp);//this.add(mp);jmb.add(jm);jm.add(jmi1);jm.add(jmi2);jm.add(jmi3);this.setSize(600,500);//this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true);//this.addKeyListener(mp);Thread t1 = new Thread(msp);t1.start();// Thread t = new Thread(mp);// t.start();}@Overridepublic void actionPerformed(ActionEvent arg0) {if(arg0.getActionCommand().equals("newGame")){mp = new MyPanel();Thread t = new Thread(mp);t.start();this.remove(msp);this.remove(mp);this.add(mp);this.setVisible(true);this.addKeyListener(mp);//Recoder.getRecording();}else if(arg0.getActionCommand()== "exit"){//Recoder.KeepRecording();Recoder.KeepExit();//KeepExit();System.exit(0);}}}class myStartPanel extends JPanel implements Runnable{ int times = 0;public void paint(Graphics g ){super.paint(g);g.fillRect(0, 0, 400, 300);if(times%2 ==0){g.setColor(Color.BLUE);Font f = new Font("华文新魏", Font.BOLD, 30);g.setFont(f);g.drawString("stage:1", 150, 150);}}@Overridepublic void run() {while(true){try {Thread.sleep(300);} catch (InterruptedException e) {e.printStackTrace();}this.repaint();times ++;}}}class MyPanel extends JPanel implements KeyListener,Runnable{ int [] TanksX = new int[20];int [] TanksY = new int[20];int [] ShotsX = new int[100];int [] ShotsY = new int[100];// int [][]Tanks = new int[20][2];// int [][]Shots = new int[20][2];int [] ETdirects = new int[20];int [] HeroShotsX = new int[10];int [] HeroShotsY = new int[10];static Hero hero = null;EnemyTask et = null;shot s = null;boolean isPaintShot = true;int a = 0, b = 0 , c = 0;int [] directs = new int [10];static //敌人坦克集合Vector<EnemyTask> ets = new Vector<EnemyTask>();int enSize = 3; //敌人坦克初始数量int enSizes = 5; //敌人坦克画面总数量int hintEnemyTanks = 0;//击中敌人坦克数量public void showInfo(Graphics g ){//画提示信息//画出提出坦克this.drawTank(80, 330, g, 0, 1);this.drawTank(160, 330, g, 0, 0);g.setColor(Color.BLACK);g.drawString(Recoder.getEnNum() + "", 105, 350);g.drawString(Recoder.getMyLife() + "", 185, 350);//画出成绩g.setColor(Color.BLACK);Font f = new Font("宋体", Font.BOLD, 15);g.setFont(f);g.drawString("你的总成绩：", 400, 20);this.drawTank(410, 30, g, 0, 1);g.drawString((20 - Recoder.getEnNum()) + "", 435, 50);}public void paint(Graphics g){super.paint(g);g.fillRect(0, 0, 400, 300);this.showInfo(g);//画出提示信息//自己坦克if(hero.isLive == true){this.drawTank(hero.getX(), hero.getY(), g, hero.direct, hero.type); }else{if(Recoder.getMyLife() > 0){hero = new Hero(30, 270 ,0,0,10 , true);hero.isLive = true;}}//画出敌人坦克for(int i = 0; i <ets.size(); i++){EnemyTask et = ets.get(i);if(!et.isLive){ets.remove(i);if(Recoder.getEnNum() >0){this.drawTank(50, 0, g, 1, 1);ets.add(et);//et.isLive = true;Thread t = new Thread(et);t.start();}// if(Recoder.getEnNum() > 0){// et.isLive = true;// }}if(et.isLive){this.drawTank(et.getX(), et.getY(),g, et.direct, et.type);System.out.println("et.ss.size()"+et.ss.size());for(int j = 0; j < et.ss.size(); j++){//敌人坦克子弹s = et.ss.get(j);if(s.isLive){if(isPaintShot){g.fill3DRect(s.x, s.y, 5, 10, false);}}else{et.ss.remove(j);}}}// if(!et.isLive){// ets.remove(i);// }}//画出子弹for(int i = 0; i< hero.ss.size(); i++){if(hero.ss.get(i)!= null && hero.ss.get(i).isLive == true){ g.fill3DRect(hero.ss.get(i).x, hero.ss.get(i).y, 5, 10, false); }if(hero.ss.get(i).isLive == false){hero.ss.remove(hero.ss.get(i));}}}// public void hintTank2(shot s , Hero et){// switch (et.direct) {// case 0:// case 1:// if(s.x < et.x + 20 && s.x > et.x// && s.y < et.y + 30 && s.y > et.y){// s.isLive = false;// et.isLive = false;// }// //break;// case 2:// case 3:// if(s.x < et.x + 30 && s.x > et.x// && s.y < et.y + 20 && s.y > et.y){// s.isLive = false;// et.isLive = false;// }// //break;////// default://// break;// }//// }public boolean hintTank(shot s , Tank et){boolean b = false;switch (et.direct) {case 0:case 1:if(s.x < et.x + 20 && s.x > et.x&& s.y < et.y + 30 && s.y > et.y){s.isLive = false;et.isLive = false;b = true;}break;case 2:case 3:if(s.x < et.x + 30 && s.x > et.x&& s.y < et.y + 20 && s.y > et.y){s.isLive = false;et.isLive = false;b = true;}break;// default:// break;}return b;}public void drawTank (int x , int y , Graphics g , int direct , int type){ switch(type){//坦克类型case 0:g.setColor(Color.RED);break;case 1:g.setColor(Color.BLUE);break;}switch (direct) {case 0://向上g.fill3DRect(x, y, 5, 30, false );g.fill3DRect(x + 15, y, 5, 30, false );g.fill3DRect(x + 5, y + 5, 10, 20, false );g.fillOval(x + 5, y + 10, 10, 10);g.drawLine(x + 10, y,x + 10, y + 15);break;case 1://向下g.fill3DRect(x, y, 5, 30, false );g.fill3DRect(x + 15, y, 5, 30, false );g.fill3DRect(x + 5, y + 5, 10, 20, false );g.fillOval(x + 5, y + 10, 10, 10);g.drawLine(x + 10, y + 15,x + 10,y + 30 ); break;case 2://向左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 , y + 10,x + 15,y + 10 );break;case 3://向右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;default:break;}}public MyPanel (){hero = new Hero(30, 270 ,0,0,10 , true);//tanks = new tank(100,100, 2 ,1);//初始化敌人坦克Recoder.setHero(hero);for(int i = 0; i < enSize; i++){//创建敌人坦克的对象Recoder.getRecording();EnemyTask et = new EnemyTask((i + 1)*50, 0, 1, 1, 5 ,true); et.setEts(ets);Recoder.setEtss(ets);//传ets到RecoderThread t = new Thread(et);t.start();shot s = new shot(et.x + 10 , et.y + 30, et.direct);et.ss.add(s);Thread t2 = new Thread(s);t2.start();ets.add(et);//加入到集合中//et.setColor(1);}Recoder.setEnSize(enSize);}@Overridepublic void keyPressed(KeyEvent arg0) {// TODO Auto-generated method stubif(arg0.getKeyCode() == KeyEvent.VK_S){//hero.setX(hero.getX() ++ 1);// int i= hero.getY();// i += hero.speed;// hero.setY(i);this.hero.MoveDown();hero.setD(1);}if(arg0.getKeyCode() == KeyEvent.VK_W){//hero.setX(hero.getX() ++ 1);// int i= hero.getY();// i -= hero.speed;// hero.setY(i);hero.MoveUp();hero.setD(0);}if(arg0.getKeyCode() == KeyEvent.VK_D){//hero.setX(hero.getX() ++ 1);// int i= hero.getX();// i += hero.speed;// hero.setX(i);hero.MoveRight();hero.setD(3);}if(arg0.getKeyCode() == KeyEvent.VK_A){//hero.setX(hero.getX() ++ 1);// int i= hero.getX();// i -= hero.speed;// hero.setX(i);hero.MoveLeft();hero.setD(2);}//判断是否按下Jif(arg0.getKeyCode() == KeyEvent.VK_J){if(hero.ss.size() <= 4){this.hero.shotEnemy();//System.out.println("j");}}if(arg0.getKeyCode() == KeyEvent.VK_SPACE){//空格暂停 if(hero.speed != 0){a = hero.speed ;hero.speed = 0;for(int i = 0; i < ets.size(); i ++){//System.out.println("aaaaaaaaaaaaaa");EnemyTask et = ets.get(i);//System.out.println("speed" + et.speed);b = et.speed;et.speed = 0;directs[i] = et.direct;//System.out.println(et.direct);//System.out.println(directs[i]);//et.direct = 0;et.isdirects = false;for(int j = 0 ; j < et.ss.size(); j ++){shot s = et.ss.get(j);c = s.speed;s.speed = 0;System.out.println("aa");}}//System.out.println("b1 =" + b);isPaintShot = false;}else{hero.speed = a;//System.out.println("a2 =" + a);for(int i = 0; i < ets.size(); i ++){//System.out.println("bbbbbbbbbbbbbbbbbbb");EnemyTask et = ets.get(i);et.isdirects = true;et.speed = b;et.direct = directs[i];for(int j = 0 ; j < et.ss.size(); j ++){shot s = et.ss.get(j);s.speed = c;isPaintShot = true;}}s.isShot = true;}}if(arg0.getKeyCode() == KeyEvent.VK_K){this.KeepExit();System.exit(0);}if(arg0.getKeyCode() == KeyEvent.VK_L){this.GetKeeper();}this.repaint();}@Overridepublic void keyReleased(KeyEvent arg0) {// TODO Auto-generated method stub}@Overridepublic void keyTyped(KeyEvent arg0) {// TODO Auto-generated method stub}@Overridepublic void run() {//每隔100mswhile(true){try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}this.hintEnemyTank();this.hintMyTank();// for(int i = 0; i < et.ss.size(); i ++){// shot myshot = et.ss.get(i);// if(et.isLive == true){//// if(hero.isLive = true){// this.hintTank2(myshot, hero);// }//// }// }this.repaint();}}private void hintMyTank() {for(int i = 0; i < ets.size(); i++){EnemyTask et = ets.get(i);for(int j = 0; j < et.ss.size(); j++ ){shot s = et.ss.get(j);if(s != null){if(hero.isLive){this.hintTank(s, hero);if(this.hintTank(s, hero)){//判断是否击中，返回true则hero数量减一Recoder.setMyLife(Recoder.getMyLife() - 1 );}}}}}}private void hintEnemyTank() {for(int i = 0; i < hero.ss.size(); i ++){shot myshot = hero.ss.get(i);if(myshot.isLive == true){for(int j = 0; j < ets.size(); j ++){EnemyTask et = ets.get(j);if(et.isLive = true){this.hintTank(myshot, et);if(this.hintTank(myshot, et)){hintEnemyTanks ++;Recoder.setEnNum(Recoder.getEnNum() - 1);}}}}}}private void KeepExit(){int [] heros = new int[]{hero.getX(),hero.getY(),hero.direct,};for(int i = 0 ; i < ets.size(); i ++){EnemyTask et = ets.get(i);TanksX[i] = et.getX();TanksY[i] = et.getY();ETdirects [i] = et.direct;for(int j = 1 ; j < et.ss.size(); j++){shot s = et.ss.get(j);ShotsX[j] = s.x;ShotsY[j] = s.y;}}for(int i = 0 ; i < hero.ss.size(); i++ ){shot s = hero.ss.get(i);HeroShotsX[i] = s.x ;HeroShotsY[i] = s.y;}BufferedWriter bw = null;try {bw = new BufferedWriter(new FileWriter("d:\\aa\\TanksX.txt")); for(int i = 0 ; i < enSize ; i ++){bw.write(TanksX[i] + "\r\n");bw.write(TanksY[i] + "\r\n");}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally {try {bw.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public void GetKeeper (){//继续游戏时还原数据BufferedReader br = null ;try {br = new BufferedReader(new FileReader("d:\\aa\\TanksX.txt")); for(int i = 0; i < enSize*2 ; i ++){if(i % 2 !=0){TanksY[i] = Integer.parseInt(br.readLine());System.out.println("TanksY" + TanksY[i]);}else{TanksX[i] = Integer.parseInt(br.readLine());System.out.println("TanksX" + TanksX[i]);}}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally {try {br.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}//class tank extends Tank{//// public tank(int x, int y, int direct,int type) {// super(x, y, direct,type);// // TODO Auto-generated constructor stub// }////}下面是工具类：package com.qq.TankGame;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.util.Vector;class Recoder{/****/private static Vector<EnemyTask> ets = new Vector<EnemyTask>(); public static Vector<EnemyTask> getEts() {return ets;}public static void setEtss(Vector<EnemyTask> ets) {Recoder.ets = ets;}private static int enSize ;public static int getEnSize() {return enSize;}public static void setEnSize(int enSize) {Recoder.enSize = enSize;}private static Hero hero ;public static Hero getHero() {return hero;}public static void setHero(Hero hero) { Recoder.hero = hero;}public static void KeepExit(){//System.out.println(hero.getX());int [] TanksX = new int[20];int [] TanksY = new int[20];int [] ShotsX = new int[100];int [] ShotsY = new int[100];int [] ETdirects = new int[20];int [] HeroShotsX = new int[10];int [] HeroShotsY = new int[10];int [] heros = new int[]{hero.getX(),hero.getY(),hero.direct};for(int i = 0 ; i < ets.size(); i ++){EnemyTask et = ets.get(i);TanksX[i] = et.getX();TanksY[i] = et.getY();ETdirects [i] = et.direct;for(int j = 1 ; j < et.ss.size(); j++){shot s = et.ss.get(j);ShotsX[j] = s.x;ShotsY[j] = s.y;}}for(int i = 0 ; i < hero.ss.size(); i++ ){ shot s = hero.ss.get(i);HeroShotsX[i] = s.x ;HeroShotsY[i] = s.y;}BufferedWriter bw = null;BufferedWriter bw1 = null ;try {bw = new BufferedWriter(new FileWriter("d:\\aa\\TanksX.txt"));for(int i = 0 ; i < enSize ; i ++){bw.write(TanksX[i] + "\r\n");bw.write(TanksY[i] + "\r\n");}bw1 = new BufferedWriter(new FileWriter("d:\\aa\\KeepRecoding.txt")); bw1.write((20 - getEnNum()) + "\r\n" );} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally {try {bw1.close();bw.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}private static int enNum = 5;public static int getEnNum() {return enNum;}public static void setEnNum(int enNum) {Recoder.enNum = enNum;}public static int getMyLife() {return myLife;}public static void setMyLife(int myLife) {Recoder.myLife = myLife;}private static int myLife = 3;private static BufferedReader br = null;public static void getRecording(){try {br = new BufferedReader(new FileReader("d:\\aa\\KeepRecoding.txt")); String n ;while((n = br.readLine()) != null ){String a = n;enNum = 20 - Integer.parseInt(n);}} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}finally {try {br.close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}private static BufferedWriter bw = null;public static void KeepRecording (){try {bw = new BufferedWriter(new FileWriter("d:\\aa\\KeepRecoding.txt")); bw.write((20 - getEnNum()) + "\r\n" );} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}finally{try {bw.close();//先开后关//new FileWriter("d:\\aa\\KeepRecoding.txt").close();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}public class Tank {int x = 0 ;int y = 0;int direct = 0; //方向int type = 0 ;//类型int speed = 30;//速度int color;boolean isLive;public int getColor() {return color;}public void setColor(int color) {this.color = color;}public int getS() {return speed;}public void setS(int speed) {this.speed = speed;}public Tank(int x , int y , int direct , int type, int speed, boolean isLive){ this.x = x;this.y = y;this.direct = direct;this.type= type;this.speed = speed;this.isLive = isLive;}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 int getD() {return direct;}public void setD(int direct) {this.direct = direct;}public int getT() {return type;}public void setT(int type) {this.type = type;}}class EnemyTask extends Tank implements Runnable{Vector<shot> ss = new Vector<shot>();Vector<EnemyTask> ets = new Vector<EnemyTask>();boolean isdirects = true;public EnemyTask(int x, int y, int direct, int type, int speed ,boolean isLive) {super(x, y, direct, type, speed, isLive);// TODO Auto-generated constructor stub}public boolean isTouchOhterTank (){boolean b = false;switch (this.direct) {case 0://此坦克向上for(int i = 0; i < ets.size(); i++){EnemyTask et = ets.get(i);if(et != this){if(et.direct == 0 || et.direct == 1){//上或下if((this.x>=et.x && this.x <= et.x + 20//第一个点x在内&& this.y>=et.y && this.y <= et.y + 30)//第一个点y在内||(this.x + 20>=et.x && this.x+ 20 <= et.x + 20//第二个点x在内&& this.y >=et.y && this.y <= et.y + 30)//第二个点y在内){b = true;}}if(et.direct == 2 || et.direct == 3){//左或右if((this.x>=et.x && this.x <= et.x + 30//第一个点x在内&& this.y>=et.y && this.y <= et.y + 20)//第一个点y在内||(this.x + 20>=et.x && this.x+ 20 <= et.x + 30//第二个点x在内&& this.y >=et.y && this.y <= et.y + 20)//第二个点y在内){b = true;}}}}break;case 1://向下for(int i = 0; i < ets.size(); i++){EnemyTask et = ets.get(i);if(et != this){if(et.direct == 0 || et.direct == 1){//上或下if((this.x>=et.x && this.x <= et.x + 20//第一个点x在内&& this.y + 30>=et.y && this.y + 30 <= et.y + 30)//第一个点y在内||(this.x + 20>=et.x && this.x+ 20 <= et.x + 20//第二个点x在内&& this.y + 30>=et.y && this.y + 30 <= et.y + 30)//第二个点y在内){b = true;}}if(et.direct == 2 || et.direct == 3){//左或右if((this.x>=et.x && this.x <= et.x + 30//第一个点x在内&& this.y + 30 >=et.y && this.y + 30 <= et.y + 20)//第一个点y在内||(this.x + 20 >=et.x && this.x+ 20 <= et.x + 30//第二个点x在内&& this.y + 30 >=et.y && this.y + 30 <= et.y + 20)//第二个点y在内){b = true;}}}}break;case 2:for(int i = 0; i < ets.size(); i++){EnemyTask et = ets.get(i);if(et != this){if(et.direct == 0 || et.direct == 1){//上或下if((this.x>=et.x && this.x <= et.x + 20//第一个点x在内&& this.y>=et.y && this.y <= et.y + 30)//第一个点y在内||(this.x >=et.x && this.x<= et.x + 20//第二个点x在内&& this.y + 20 >=et.y && this.y + 20 <= et.y + 30)//第二个点y在内){b = true;}}if(et.direct == 2 || et.direct == 3){//左或右if((this.x>=et.x && this.x <= et.x + 30//第一个点x在内&& this.y>=et.y && this.y <= et.y + 20)//第一个点y在内||(this.x >=et.x && this.x<= et.x + 30//第二个点x在内&& this.y + 20>=et.y && this.y + 20 <= et.y + 20)//第二个点y在内){b = true;}}}}break;case 3:for(int i = 0; i < ets.size(); i++){EnemyTask et = ets.get(i);if(et != this){if(et.direct == 0 || et.direct == 1){//上或下if((this.x + 30>=et.x && this.x + 30 <= et.x + 20//第一个点x在内&& this.y>=et.y && this.y <= et.y + 30)//第一个点y在内||(this.x + 30 >=et.x && this.x+ 30 <= et.x + 20//第二个点x在内&& this.y + 20 >=et.y && this.y + 20 <= et.y + 30)//第二个点y在内){b = true;}}if(et.direct == 2 || et.direct == 3){//左或右if((this.x + 30>=et.x && this.x + 30 <= et.x + 30//第一个点x在内&& this.y>=et.y && this.y <= et.y + 20)//第一个点y在内||(this.x + 30>=et.x && this.x+ 30 <= et.x + 30//第二个点x在内&& this.y + 20>=et.y && this.y + 20 <= et.y + 20)//第二个点y在内){b = true;}}}}break;default:break;}return b ;}@Overridepublic void run() {int a = (int) (Math.random() * 10 + 2);//连动步数int times = 0;while(true){try {Thread.sleep(300);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//if(x > 0 && x < 400 - 30 & y > 0 && y < 300 - 30){ //if(!this.isTouchOhterTank()){switch(this.direct){case 0://System.out.println(isTouchOhterTank());for(int i = 0 ;i < a ; i++){if(y - this.speed > 0 && !this.isTouchOhterTank()){y -= this.speed;}try {Thread.sleep(50);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}break;case 1:for(int i = 0 ;i < a ; i++){if(y + speed < 300 - 30 && !this.isTouchOhterTank()){ y += this.speed;}try {Thread.sleep(50);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}break;case 2:for(int i = 0 ;i < a ; i++){if(x - speed > 0 && !this.isTouchOhterTank()){x -= this.speed;}try {Thread.sleep(50);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}break;case 3:for(int i = 0 ;i < a ; i++){if(x + speed < 400 - 30 && !this.isTouchOhterTank()){ x += this.speed;}try {Thread.sleep(50);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}break;}//}times ++;if(times % 2 == 0){if(isLive){if(ss.size() < 3){shot s = null;switch (direct) {case 0://向上s = new shot(x + 10 , y ,0);ss.add(s);break;case 1://向下s = new shot(x + 10 , y + 30 , 1);ss.add(s);break;case 2://向左s = new shot(x , y + 10 , 2);ss.add(s);break;case 3://右s = new shot(x + 30 , y + 10 , 3);ss.add(s);break;default:break;}Thread t = new Thread(s);t.start();}}}//}// //随机改变方向// public void changeDirect(){//// }if(isdirects){this.direct = (int) (Math.random() * 4); }if(this.isLive == false){break;}if(ss.size() < 3){}}}public void setEts(Vector<EnemyTask> ets) { this.ets = ets;}// @Override// public void run() {// while(true){// try {// Thread.sleep(50);// } catch (InterruptedException e) {// // TODO Auto-generated catch block// e.printStackTrace();// }//// y ++ ;// System.out.println(y);// }//// }}class Hero extends Tank{//public Hero(int x , int y, int direct, int type,int speed, boolean isLive){super(x, y, direct, type,speed , isLive);}Vector<shot> ss = new Vector<shot>();shot s = null;//开火public void shotEnemy(){//System.out.println("shotEnemy");if(Recoder.getMyLife() > 0){//生命没有了，不能发子弹 switch (this.direct) {case 0://向上s = new shot(x + 10 , y ,0);ss.add(s);break;case 3://右s = new shot(x + 30 , y + 10 , 3);ss.add(s);break;case 1://向下s = new shot(x + 10 , y + 30 , 1);ss.add(s);break;case 2://向左s = new shot(x , y + 10 , 2);ss.add(s);break;default:break;}Thread t = new Thread(s);t.start();}}//向上,下，左，右public void MoveUp(){if(y - this.speed > 0){y -= speed;}}public void MoveDown(){if(y + this.speed < 300 -30){y += speed;}}public void MoveLeft(){if(x - this.speed > 0){x -= speed;}}public void MoveRight(){if(x + this.speed < 400 -30){x += speed;}}}class shot implements Runnable{int x ,y;int direct;int speed = 20; //子弹速度boolean isShot = true;boolean isLive = true;//子弹是否活着 public shot(int x,int y, int direct){this.x = x;this.y = y;this.direct = direct;}@Overridepublic void run() {while(true){try {Thread.sleep(50);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}if(isShot){switch (direct) {case 0://向上y -= speed;break;case 1://下y += speed;break;case 2://右x -= speed;break;case 3://左x += speed;break;default:break;}}//System.out.println(x + " " + y);if(x < 0 || x > 400 || y < 0 || y > 300){ //System.out.println("this.islive = false");this.isLive = false;break;}}} }。

JAVA课程设计坦克大战游戏(含代码)

Java课程设计任务书简单电子游戏坦克大战的设计1、主要内容：设计一个简单的坦克大战电子游戏，可以允许多位玩家在局域网中同时对战2、系统要求：游戏具有图形游戏界面，能让用户看到游戏所给出的反馈。

有人机交互功能，使用户操作指定的游戏元素，并且坦克具有生命值，能攻击敌方，无法攻击友方，而且坦克的攻击具有视觉效果！3、具体要求（包括技术要求等）：1.需要有图形游戏界面，让用户能看到游戏给出的反馈2.有人机交互功能，使用户能操作指定的游戏元素3.不同队伍的坦克，须显示不同外观，已分辨敌我4.坦克能够开火，攻击敌方，但不能攻击队友5需要有不可被子弹穿透的墙6.坦克有生命值，并非被击中一次就会爆炸7游戏结束后可重新开始学习并掌握以下技术：Java、JavaBean 等熟练使用以下开发工具：Myeclipse 等实现系统上述的功能。

4、进度安排：12月28日~ 12月29日：课程设计选题，查找参考资料12月30日~ 1月1日：完成系统设计和数据库设计1月2日~ 1月4日：完成程序代码的编写1月4日~ 1月5日：系统测试与完善1月5日~ 1月6日：完成课程设计报告，准备答辩分工：随着计算机的普及以及对电子游戏的认识，电子游戏已被越来越多的人选作放松、娱乐的休闲方式；电子游戏既不需要专门购买游戏器材，也不需要宽阔的游戏场地，只需要一台能独立完成任务的计算机即可，它可以是人们工作、学习时用的计算机，并不需要另行配置，这比起传统休闲游戏即省钱又省事。

局域网游戏更是可以将现实空间中零散的计算机，组织起来，使其在逻辑空间中集中起来，使游戏的组织、开展变得轻松。

如此轻松而又安逸的休闲方式，使得越来越多的人尝试，甚至已经将电子游戏作为主要休闲方式，既然有如此多的人使用，那其中必然存在巨大的商机，即使人们不愿意为一个小小的休闲游戏花费金钱，但在游戏中添加广告、游戏相关服务也包藏了巨大的财富；当然电子游戏的制作如今已是空前的火爆，大大小小的游戏公司横空出世，都想在电子游戏制作这个行业里占据一席之地，而一款成功的电子游戏需要精心的策划、分析、设计，只有这样才能获得游戏中包藏的财富，以及做出一款真正能够让玩家娱乐、放松的游戏，而不是骗取玩家钱财的工具。

JAVA实现经典游戏坦克大战的示例代码

JAVA实现经典游戏坦克⼤战的⽰例代码⽬录前⾔主要设计功能截图代码实现总结前⾔⼩时候⼤家都玩过坦克⼤战吧，熟悉的旋律和丰富的关卡陪伴了我们⼀整个寒暑假，还记得传说中的经典坦克⼤战吗？那些怀旧的记忆，伴随着我们⼀起⾛过来的经典坦克⼤战，刚开始那战战兢兢，屡屡被敌⼈坦克击毁的情景历历在⽬。

现在好了，再也不⽤担⼼敌⼈坦克了，可以横冲直撞，横扫敌⼈坦克了。

快哉《坦克⼤战》游戏以坦克战⽃为主题，⽤java语⾔实现，采⽤了swing技术进⾏了界⾯化处理，设计思路⽤了⾯向对象思想。

主要需求可以⽣成不同的地图，消灭地图上的所有坦克为胜利；可以设置关卡地图，不断增加难度。

主要设计1、要有难度关卡：第⼀关，第⼆关，第三关，第四关，第五关；第⼀关地图最简单，第五关地图最难；2、坦克要有⾎条，打多次才会死3、地图要我有我⽅坦克四辆（相当于4条命）和多辆敌⽅坦克4、我⽅坦克的炮弹数量是固定的，设置为5005、地图右边显⽰基本信息6、地图上要在砖块，铁块，河流功能截图游戏开始页⾯代码实现窗⼝布局public class GameFrame extends JFrame {/*** serialVersionUID*/private static final long serialVersionUID = -1176914786963603304L;public GameFrame() {super();this.setSize(800, 700);this.setTitle("坦克⼤战");this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);this.setResizable(false);// 显⽰器屏幕⼤⼩Dimension screenSizeInfo = Toolkit.getDefaultToolkit().getScreenSize();int leftTopX = ((int) screenSizeInfo.getWidth() - this.getWidth()) / 2;int leftTopY = ((int) screenSizeInfo.getHeight() - this.getHeight()) / 2;// 设置显⽰的位置在屏幕中间this.setLocation(leftTopX, leftTopY);}}地图渲染核⼼算法@Servicepublic class PaintService {@Autowiredprivate GameContext context;private Brick rightBrick = new Brick(700, 50);private Iron rightIron = new Iron(700, 50);private Water rightWater = new Water(700, 50);/*** 画出东西（包括坦克、障碍物。

java简单坦克大战制作代码

java简单坦克⼤战制作代码利⽤Java语⾔中的集合、Swing、线程等知识点编写⼀个坦克⼤战游戏。

（1）画出敌我坦克的原理：在坦克类⾥⾯有⼀个布尔类型变量good。

⽤于判断坦克的阵营，在创建坦克对象时在Tank类的构造⽅法中传⼊good的值。

在画坦克的时候判断good的值，区分敌我坦克的颜⾊；（2）坦克运动的原理：在坦克类⾥写⼊了监听键盘摁键的响应事件，对监听到的上下左右键进⾏记录，并合成坦克移动的⼋个⽅向的变量。

之后对应每个⽅向的不同对坦克坐标x，y的值做响应的更改实现我⽅坦克的移动。

⽽敌⽅坦克则⾃动移动，通过随机数对敌⽅坦克移动⽅向的随机，并且随机出每次移动的次数。

两个随机值相结合即实现了敌⽅坦克的移动。

（3）坦克发射⼦弹的原理：通过键盘监听，检测到发射⼦弹命令后将主类的⼦弹类集合中添加⼀个⼦弹类。

将炮筒的⽅向以及坦克的位置以及坦克的阵营传⼊给⼦弹类，在主类paint画⽅法中⼀直循环⼦弹类集合，如果集合内有⼦弹，就画出来。

这样就实现了发射⼦弹。

（4）坦克、⼦弹、墙的碰撞原理：在坦克类⼦弹类墙类中分别getRect⽅法获取⾃⾝的范围，然后在每次画坦克、⼦弹时都会进⾏相应的碰撞检测（在坦克类⾥有与墙和出⾃⼰外的坦克相撞的处理⽅法、在⼦弹类⾥有与墙和坦克相碰撞的处理⽅法。

），如果⾃⾝与不该碰撞的物体的范围相重合，则代表两物体相撞。

（5）坦克加⾎的原理：在⾎块类中有⾎块与我⽅坦克相碰撞的处理⽅法，如果⾎块范围与坦克范围重合则⾎块类死亡，并且坦克类的⾎量回复置满。

（6）坦克复活的原理：通过键盘监听，检测到我⽅坦克复活命令后，如果我⽅坦克处于死亡状态，则将我⽅坦克存货状态改为活着并且将我⽅坦克⾎量回置满⾎。

编程思想：坦克⼤战的编程思想在主类开启⼀个线程，没50毫秒循环⼀次画⽅法（绘制整个界⾯内的所有东西）。

画的东西有敌我坦克（颜⾊区分）、⼦弹、墙、⾎块、爆炸。

所以总共写出了⼏个类：Tank坦克类、Missile⼦弹类、Wall墙类、Blood ⾎块类、TankClient主类。

坦克大战【java项目】

坦克⼤战【java项⽬】坦克⼤战（JAVA项⽬）1.项⽬简介复刻童年经典⼩游戏——坦克⼤战：⽤户进⼊游戏界⾯后，通过键盘上的数字1，2键选择游戏模式，选择1并按回车键进⼊单⼈模式；选择2并按回车键进⼊双⼈模式。

玩家1可通过按键WASD控制坦克⽅向及移动，并且按空格发射⼦弹。

玩家2通过⽅向键控制坦克⽅向移动，并且按K键发射⼦弹。

⼦弹碰到围墙后消失，⼦弹碰到坦克后产⽣爆炸特效。

左上⾓记录敌⽅坦克的实时数量。

玩家击败所有敌⽅坦克，游戏胜利；若所有我⽅坦克被击败，或者我⽅基地被摧毁，则游戏失败。

2.⼩组成员及分⼯成员负责任务组长黄抒鸿博客撰写，游戏规则的制定，碰撞检测，爆炸特效的实现，随机事件的编写组员雷正伟前期调研，⾯向对象设计，窗体绘制，闪动问题的解决，键盘事件的编写3.项⽬功能架构图与主要功能流程图3.1项⽬功能架构图3.2主要功能流程图3.3⾯向对象类设计图4.功能详解4.1 窗体绘制及添加键盘事件4.1.1 创建窗⼝·创建类继承JFrame·创建启动⽅法launch()4.1.2 为窗⼝上⾊·重写paint()⽅法，设置图形颜⾊和⼤⼩4.1.3 添加选项⽂字4.1.4 为窗⼝添加键盘事件添加内部类，实现KeyAdapter类，重写keyPressed⽅法，写⼊键盘事件，1选择单⼈模式，2选择双⼈模式窗⼝添加键盘监视器添加指针图⽚在项⽬⽂件夹下创建⽂件夹images，关于项⽬的图⽚，插件都放在这个⽂件夹内创建图⽚对象在launch()⽅法中重绘图形4.2双缓冲解决闪动问题创建⼀个图⽚Image offScreemImage = null;重写paint()⽅法创建⼀个和弹出窗⼝宽⾼相同的图⽚，获取该图⽚的图形对象，把所有内容添加到该图⽚中//创建和容器⼀样⼤⼩的Image图⽚if(offScreemImage == null) {offScreemImage = this.createImage(width,height);}//获的该图⽚的图形Graphics gImage = offScreemImage.getGraphics();gImage.setColor(Color.GRAY);gImage.fillRect(0, 0, width, height);//添加游戏选项gImage.setColor(Color.BLUE);gImage.setFont(new Font("仿宋", Font.BOLD, 50));if (state == 0 ) {gImage.drawString("选择游戏模式", 220, 100);gImage.drawString("单⼈模式", 220, 200);gImage.drawString("双⼈模式", 220, 300);//绘制指针gImage.drawImage(select, 160, y, null);} else if (state ==1 || state ==2) {gImage.drawString("游戏开始", 220, 100);if (state ==1) {gImage.drawString("单⼈模式", 220, 200);} else if(state ==2) {gImage.drawString("双⼈模式", 220, 200);}}4.3⾯向对象设计游戏⽗类：坦克类：玩家⼀和玩家⼆玩家2和玩家1的⽅法都是⼀样的，只需要修改键盘事件。

坦克大战游戏编程实现

坦克大战游戏编程实现游戏编程实现坦克大战坦克大战是一款经典的电子游戏，在游戏中，玩家将控制一个坦克，通过操作坦克的移动和攻击，与其他玩家或电脑进行战斗。

本文将介绍如何使用编程语言实现坦克大战游戏。

设计思路在实现坦克大战游戏之前，首先需要明确游戏的基本要素和规则。

玩家将操作一个坦克，通过键盘或操纵杆控制坦克的移动和攻击。

游戏画面由地图、坦克、子弹等元素构成。

坦克可以向前、向后、向左、向右移动，可以发射子弹进行攻击。

玩家需要躲避敌方坦克的攻击，同时尽可能击败敌方坦克。

编程实现坦克的移动和攻击可以通过编程语言来实现。

以下是使用Java语言来编写坦克大战游戏的示例代码：```javapublic class TankGame extends JFrame {private Tank tank; // 玩家坦克private List<Tank> enemyTanks; // 敌方坦克列表private List<Bullet> bullets; // 子弹列表public TankGame() {// 初始化游戏窗口this.setSize(800, 600);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); this.setVisible(true);// 初始化玩家坦克tank = new Tank(400, 500);// 初始化敌方坦克列表enemyTanks = new ArrayList<>();enemyTanks.add(new Tank(100, 100));enemyTanks.add(new Tank(300, 200));// 初始化子弹列表bullets = new ArrayList<>();// 添加键盘监听器，控制坦克移动和攻击this.addKeyListener(new KeyListener() {@Overridepublic void keyPressed(KeyEvent e) {int keycode = e.getKeyCode();switch (keycode) {case KeyEvent.VK_UP:tank.moveUp();break;case KeyEvent.VK_DOWN: tank.moveDown();break;case KeyEvent.VK_LEFT: tank.moveLeft();break;case KeyEvent.VK_RIGHT: tank.moveRight();break;case KeyEvent.VK_SPACE: bullets.add(tank.fire());break;default:break;}// 重新绘制游戏画面repaint();}@Overridepublic void keyReleased(KeyEvent e) { }@Overridepublic void keyTyped(KeyEvent e) { }});}// 绘制游戏画面public void paint(Graphics g) {super.paint(g);// 绘制玩家坦克tank.draw(g);// 绘制敌方坦克for (Tank enemyTank : enemyTanks) { enemyTank.draw(g);}// 绘制子弹for (Bullet bullet : bullets) {bullet.draw(g);}}public static void main(String[] args) {new TankGame();}}```在上述示例代码中，我们创建了一个继承自JFrame的主窗口，并在窗口中添加了一个玩家坦克、敌方坦克和子弹的列表。

JAVA课程设计坦克大战(含代码)

Java程序课程设计任务书项目名称：坦克大战游戏的设计与开发英文名：Tank Battle1、主要内容：1、基于java的游戏开发与设计的分析；2、坦克大战游戏的架构搭建与设计实现；3、游戏可以通过用户可以注册新用户，修改自己的密码、个人资料。

2、具体要求1、系统的功能要求：（一）实现玩家试玩游戏功能，屏蔽用户注册和登陆功能（空功能）（二）玩家具备一个或者两个备选坦克战车（三）玩家可以选择一个到两个关卡进行作战（四）玩家可以选择两个敌对阵营中的一个加入，与其他AI战车坦克并肩作战（五）胜利判定条件为：时间制、全杀制（可选）（六）至少提供两个可以自由切换的视角（七）至少提供一种炮弹类型（八）假定项目：如果用户注册，登陆功能能够顺利做好，则提供一个玩家分数上传和排行榜功能。

2、学习并掌握以下技术：数据库的JDBC连接，JA V A编程语言，MySQL数据库的应用；JSP的开发与运用3、熟练使用以下开发工具：JCreator，Myeclipse ,MySQL ,PowerDesigner 等3、进度安排：12月28日~ 12 月29 日：查阅资料，完成文献综述，任务书；12月29 日~ 12月31日：进行系统的需求分析与设计；1月1日~ 1月3日：根据分析进行各个模块程序的设计与创建；1月4日~ 1 月6日：完成各个模块的程序编写；1月7 日~ 1 月8 日：完成全部程序的编写及系统测试；1月9日~ 1 月10日：完成课程设计报告的编写，答辩；摘要随着Java语言的不断发展和壮大，现在的Java已经广泛的应用于各个领域，包括医药，汽车工业，手机行业，游戏，等等地方。

Java游戏的开发为满足人们娱乐所需而设计。

本游戏为坦克大战游戏，是基于Java的图形用户界面而开发的，可以放松心情的小游戏。

游戏从系统操作简便、界面友好、灵活、上手即会的基本要求出发，完成整款游戏的开发。

游戏更设置了暂停、计分、音乐、速度，用户信息保存等功能，可以根据自己的爱好，挑战更高难度，为用户带来愉悦的体验。

java课程设计--坦克大战游戏(带源码)

g.setColor(Color.RED);
g.drawRect(x,y-5, WIDTH,5);
int w=WIDTH*life/100;
g.fillRect(x, y-5, w, 5);
g.setColor(c);
}
}
private class BloodBar_B{
public void draw(Graphics g){
}
Graphics gOffScreen=offScreenImage.getGraphics();
Color c=gOffScreen.getColor();
gOffScreen.setColor(Color.GRAY);
gOffScreen.fillRect(0, 0,GAME_WIDTH,GAME_HEIGHT);
g.drawString("击中个数："+explodes.size(),10,70);
g.drawString("坦克数量："+tanks.size(),10,90);
g.drawString("生命值："+myTank.getLife(),10,110);
if(tanks.size()<=0){
public static final int HEIGHT = 30;
private boolean live = true;
private BloodBar_G bb_G=new BloodBar_G();
private BloodBar_B bb_B=new BloodBar_B();
private int life =100;
Color c=g.getColor();

Java版坦克大战游戏毕业设计

1 引言1．1开发背景随着人们精神文化生活的日益丰富，为了让我们在闲暇的时间多方面发展个人的兴趣爱好，为了更好地开发个人智力，游戏成为人们生活中不可缺少的一部分。

游戏产业促动高科技技术不断升级，作为经济增长的一大支撑点，已经成为经济腾飞的“第四产业”。

作为休闲游戏的起源应该追溯到早期的俄罗斯方块和坦克大战，坦克大战是童年经常玩的游戏，也是一款经典游戏。

《坦克大战》游戏几乎家喻户晓，对我们80后90后而言，是童年最珍贵的回忆。

此款游戏是一款以红白机为平台操作射击游戏[1]，玩家可以控制自己的坦克，以歼灭对方的坦克，其操作方式及其简单，是一款男女老少皆宜的游戏。

为了满足人们的个性化需求，使玩家在游戏的过程中，更能体验游戏本身的乐趣，也为了满足更好的用户体验，市场上逐渐出现了《墨水坦克大战[2]》，它是经典坦克大战的姊妹游戏，只有手机版，没有PC版，所以决定在自己大学毕业之时，开发一个PC版的《墨水坦克大战》。

1．2国内外单机游戏的研究现状近年来，由于经济的迅速发展，科技日新月异的变化，越来越多的人会把电脑作为一种娱乐工具，而不仅仅是用它来工作，单机游戏又凭借自身操作简单，价格低廉，对电脑的配置要求低，有利于各个阶层各个行业人士使用，并且有益于身心健康，在琳琅满目的游戏中脱颖而出。

但是，对于我国国内单机游戏而言，还处于起步阶段，有着较大的商业潜力，但是也存在着正版维护意识不强，从而使得盗版有机可乘，影响市场的健全发展，还需要得到进一步的更健全的发展[3]。

1．3研究意义单机游戏由于其不必联入互联网也可以进行游戏，从而摆脱了很多限制，只要有一台电脑即可体验游戏带来的欢乐，现在许多的单机游戏都是精工细致而成的，更能呈现出友好的界面，流畅的画面，悦耳的背景音乐，良好的游戏性。

《墨水坦克大战》只有手机版，使得手机屏幕小或者配置低的用户很难体验到《墨水坦克大战》的妙趣横生，开发PC版的《墨水坦克大战》势在必行。

坦克大战Java代码Tank

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 boolean live = true; //初始化生命为trueprivate BloodBar bb = new BloodBar();//声明血块变量private int life = 100; //初始化生命值为100TankClient tc;//生命坦克客户端变量private boolean good;//设置区分敌我两方标志private int x, y; //声明两个整型私有变量x,y坐标private int oldX, oldY;//记录上一步的坐标private static Random r = new Random(); //创建一个随机数r对象//声明方向变量private boolean bL=false, bU=false, bR=false, bD = false;enum Direction {L, LU, U, RU, R, RD, D, LD, STOP};/*坦克的八个方向和一个stop 状态*/private Direction dir = Direction.STOP;private Direction ptDir = Direction.D;private int step = r.nextInt(12) + 3;//整数step在[3,14]间随机取值//构造方法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.RED);//我方坦克颜色设置为红色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();}//移动方法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(12) + 3;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_Q :if(!this.live) {this.live = true;this.life = 100;}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;}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 =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_A ://按下A开火superFire();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 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++) {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 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;}}。

Java课程设计——坦克大战

Java课程设计——坦克⼤战坦克⼤战——坦克类⼀. 团队课程设计博客链接⼆.个⼈负责模块和任务说明模块：坦克类（玩家坦克类+电脑坦克类），代码整合三.代码的提交记录截图四.负责模块和任务详细说明玩家坦克继承VisibleImage类，电脑坦克类继承⾃玩家坦克类，UML如下：1.玩家坦克类构造⽅法：设置坐标位置（坦克出⽣的位置），坦克的图⽚，坦克的类型（玩家还是电脑），⾯板（可将坦克放置于当前⾯板中），代码截图如下：移动⽅向：（上下左右）左移思路：若当前⽅向不是左移，则将图⽚更改为左移图⽚，并且更新⽅向为左。

若经过碰撞检测发现不会产⽣碰撞，则改变坐标，并且要判断坐标是否在边界。

其他⽅向同理,代码截图如下：碰撞检测：（墙与电脑坦克）思路：获取当前坐标周围⼀定范围内的矩形边框，同时获取当前⾯板内的所有墙体对象，将其存放于数组中。

将获得的矩形范围与所有墙体互相匹配，若符合则说明会产⽣碰撞。

注意草地例外。

坦克碰撞检测同理，注意要将⾃⼰除外，并且要查看当前坦克是否存活，代码截图如下：获得⼦弹：根据上下左右的⽅向判断坦克头的位置，即⼦弹发射的⽅向的预设，以保证之后⼦弹朝预设⽅向移动（⼦弹的移动在⼦弹类⾥）攻击⽅法：获得⼦弹，将⼦弹添加⾄⾯板（因为⼦弹有四个⽅向），启动攻击冷却线程。

触碰边界⽅法：根据屏幕与主窗体之间的⼤⼩关系，进⽽判断坦克是否移动到边界。

冷却线程：使⽤sleep（）⽅法，经过休眠之后，要注意改变线程的状态，将其改为可攻击。

其余setter，getter⽅法则不进⾏详细描述。

2.电脑坦克类构造⽅法：继承⾃⽗类玩家坦克类，设置好初始⽅向，攻击冷却时间移动⽅向：在⽗类的基础上，改变了⽗类的⼿动产⽣新⽅向，⽽是随机产⽣新⽅向，并且在该⽅向的移动时间是设置好的，检测是否达到边界同理：碰撞检测，攻击⽅法的思路都与玩家坦克类相似，不同之处在于，玩家坦克类的⽅向是⼈为改动的，⽽电脑坦克类的⽅向是随机产⽣的，故要重写⽗类的这两个⽅法。

java 坦克大战游戏教程完整代码

项目：用java做的坦克大战效果图：进入《坦克大战》游戏主界面点击开始菜单，即可进入游戏：使用W/A/S/D控制坦克移动，使用J发射子弹消灭所有坦克游戏获得胜利，被击中后，游戏将会结束：完整代码见下文，需要准备一个进入坦克大战的音乐声音，放在TankVs.java代码文件的同路径的shengyin文件夹下。

（没有也可以）代码运行方法：1，在以及配置好java JDK的情况下，将下面的完整的代码复制到并粘贴到记事本内，并将后缀.txt改为.java，文件命名为TankVs.java。

2，运行cmd，使用javac TankVs.java命令编译该java文件，编译成功后，使用java TankVs 命令即可运行游戏。

//以下为完整的坦克游戏代码import java.awt.*;import javax.swing.*;import java.awt.event.*;import java.util.*;import java.io.*;import javax.sound.sampled.*;//导入声音类包public class TankVs extends JFrame implements ActionListener,Runnable{OverPanel op=null;WinPanel wp=null;FirstPanel fmp=null;MyPanel mp=null;JMenuBar jmb=null;JMenu jm=null;JMenuItem jmi=null;public static void main(String[] args){TankVs tk1=new TankVs();}public TankVs(){fmp=new FirstPanel();jmb=new JMenuBar();jm=new JMenu("开始");jmi=new JMenuItem("开始游戏");jm.add(jmi);jmb.add(jm);this.setJMenuBar(jmb);this.add(fmp);jmi.addActionListener(this);//添加单击事件监听this.setSize(1000,800);this.setLocation(200,100);this.setTitle("坦克大战");//文件的路径自己改一下this.setIconImage(new ImageIcon("D:\\JAVA\\高级\\坦克大战\\image\\tank.jpg").getImage());this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setResizable(false);this.setVisible(true);Thread t=new Thread(fmp);t.start();}public void actionPerformed(ActionEvent e){if(fmp!=null){this.remove(fmp);}if(op!=null){this.remove(op);}if(wp!=null){this.remove(wp);}mp=new MyPanel();mp.repaint();this.addKeyListener(mp);//添加键盘事件监听this.add(mp);Thread t=new Thread(mp);t.start();this.setVisible(true);Thread t1=new Thread(this);t1.start();shengyin sy=new shengyin(".\\shengyin\\tank.wav");sy.start();}public void run(){while(true){try{Thread.sleep(50);}catch(Exception e){}if(this.mp.dtk.size()==0){try{Thread.sleep(1000);}catch(Exception e){}this.wp=new WinPanel();this.add(wp);this.remove(mp);this.setVisible(true);}if(this.mp.mt.shengming==false){try{Thread.sleep(1000);}catch(Exception e){}this.op=new OverPanel();this.add(op);this.remove(mp);this.setVisible(true);}}}}class FirstPanel extends JPanel implements Runnable{int times=0;public void paint(Graphics g){super.paint(g);g.fillRect(0,0,800,600);if(times%2==0){g.setColor(Color.yellow);Font myFont=new Font("华文行楷",Font.BOLD,80);g.setFont(myFont);g.drawString("坦克大战",230,300);}}public void run(){while(true){try{Thread.sleep(500);}catch(Exception e){}times++;this.repaint();}}}class OverPanel extends JPanel{public void paint(Graphics g){super.paint(g);g.fillRect(0,0,800,600);g.setColor(Color.yellow);g.setFont(new Font("Cambria",Font.BOLD,80));g.drawString("GAME OVER",200,300);}}class WinPanel extends JPanel{public void paint(Graphics g){super.paint(g);g.fillRect(0,0,800,600);g.setColor(Color.yellow);g.setFont(new Font("Cambria",Font.BOLD,80));g.drawString("YOU WIN",200,300);}}class MyPanel extends JPanel implements KeyListener,Runnable{WoTank mt=null;Vector<DiTank> dtk=new Vector<DiTank>();//集合类+泛型，Vector适用与多线程，int tks=12;public MyPanel(){mt=new WoTank(260,500);mt.setSudu(8);for(int i=0;i<tks;i++){DiTank dt=new DiTank((750/(tks-1))*i,20);dt.setSudu(2);dtk.add(dt);Thread t=new Thread(dt);//启动敌人坦克线程t.start();}}public void paint(Graphics g){super.paint(g);g.fillRect(0,0,800,600);if(mt.shengming==true){this.drawTank(mt.getX(),mt.getY(),g,mt.getFangxiang(),0);//绘制我方坦克}for(int i=0;i<dtk.size();i++){DiTank dt=dtk.get(i);this.drawTank(dt.getX(),dt.getY(),g,dt.getFangxiang(),1);if(dt.zd.shengming==true){g.setColor(Color.white);g.fill3DRect(dt.zd.x,dt.zd.y,3,3,false);//绘制敌方坦克}}for(int i=0;i<mt.aa.size();i++)//绘制子弹{Zidan zd=mt.aa.get(i);if(zd.shengming==true && mt.shengming==true){g.setColor(Color.red);g.fill3DRect(zd.x,zd.y,3,3,false);}if(zd.shengming==false){mt.aa.remove(zd);}}}public void drawTank(int x,int y,Graphics g,int fangxiang,int leixing){switch(leixing){case 0://我的坦克g.setColor(Color.yellow);break;case 1://敌人的坦克g.setColor(Color.green);break;}switch(fangxiang){case 0://上方向g.fill3DRect(x,y,5,30,false);g.fill3DRect(x+15,y,5,30,false);g.fill3DRect(x+5,y+5,10,20,false);g.fillOval(x+5,y+10,10,10);g.drawLine(x+10,y+15,x+10,y-3);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-3,y+10);break;case 2://下方向g.fill3DRect(x,y,5,30,false);g.fill3DRect(x+15,y,5,30,false);g.fill3DRect(x+5,y+5,10,20,false);g.fillOval(x+5,y+10,10,10);g.drawLine(x+10,y+15,x+10,y+33);break;case 3://右方向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+33,y+10);break;}}public void keyTyped(KeyEvent e){}public void keyReleased(KeyEvent e){}public void keyPressed(KeyEvent e){if(mt.shengming==true){if(e.getKeyCode()==KeyEvent.VK_W){this.mt.setFangxiang(0);this.mt.xiangshang();}else if(e.getKeyCode()==KeyEvent.VK_A)this.mt.setFangxiang(1);this.mt.xiangzuo();}else if(e.getKeyCode()==KeyEvent.VK_S){this.mt.setFangxiang(2);this.mt.xiangxia();}else if(e.getKeyCode()==KeyEvent.VK_D){this.mt.setFangxiang(3);this.mt.xiangyou();}if(e.getKeyCode()==KeyEvent.VK_J){if(mt.aa.size()<8)//允许我的坦克同时存在8颗子弹{this.mt.fszd();Thread t=new Thread(this);//启动画板线程t.start();}}}this.repaint();}public void run(){while(mt.zd.shengming==true ||dtk.size()>0){try{Thread.sleep(50);}catch(Exception e){}for(int i=0;i<mt.aa.size();i++){Zidan zd=mt.aa.get(i);for(int j=0;j<dtk.size();j++){DiTank dt=dtk.get(j);this.jzdf(zd,dt);}for(int i=0;i<dtk.size();i++){DiTank dt=dtk.get(i);this.jzwf(dt.zd,mt);}this.repaint();//System.out.println("线程1");}}public void jzdf(Zidan zd,DiTank dt)//击中敌方{switch(dt.fangxiang){case 0:case 2:if(zd.x>dt.getX() && zd.x<dt.getX()+20 && zd.y>dt.getY() && zd.y<dt.getY()+30){zd.shengming=false;dt.shengming=false;mt.aa.remove(zd);dtk.remove(dt);}break;case 1:case 3:if(zd.x>dt.getX() && zd.x<dt.getX()+30 && zd.y>dt.getY() && zd.y<dt.getY()+20){zd.shengming=false;dt.shengming=false;mt.aa.remove(zd);dtk.remove(dt);}break;}}public void jzwf(Zidan zd,WoTank mt)//击中我方{if(mt.shengming==true){switch(mt.fangxiang){case 0:case 2:if(zd.x>mt.getX() && zd.x<mt.getX()+20 && zd.y>mt.getY() && zd.y<mt.getY()+30){zd.shengming=false;mt.shengming=false;}break;case 1:case 3:if(zd.x>mt.getX() && zd.x<mt.getX()+30 && zd.y>mt.getY() && zd.y<mt.getY()+20){zd.shengming=false;mt.shengming=false;}break;}}}}class Tank{private int x=0,y=0;int fangxiang=0;int sudu=1;boolean shengming=true;public int getSudu(){return sudu;}public void setSudu(int sudu){this.sudu=sudu;}public int getFangxiang(){return fangxiang;}public void setFangxiang(int fangxiang){this.fangxiang=fangxiang;}public int getX(){return x;}public int getY(){return y;}public void setX(int x){this.x=x;}public void setY(int y){this.y=y;}public Tank(int x,int y){this.x=x;this.y=y;}}class WoTank extends Tank{Zidan zd=new Zidan();Vector<Zidan> aa=new Vector<Zidan>();public WoTank(int x,int y){super(x,y);}public void xiangshang(){if(getY()-sudu>0){this.setY(this.getY()-sudu);}}public void xiangzuo(){if(getX()-sudu>0){this.setX(this.getX()-sudu);}}public void xiangxia(){if(getY()+sudu<520){this.setY(this.getY()+sudu);}}public void xiangyou(){if(getX()+sudu<750){this.setX(this.getX()+sudu);}}public void fszd(){switch(this.fangxiang){case 0:zd=new Zidan(super.getX()+10,super.getY(),super.getFangxiang(),true);break;case 1:zd=new Zidan(super.getX(),super.getY()+10,super.getFangxiang(),true);break;case 2:zd=new Zidan(super.getX()+10,super.getY()+30,super.getFangxiang(),true);break;case 3:zd=new Zidan(super.getX()+30,super.getY()+10,super.getFangxiang(),true);break;}aa.add(zd);Thread t=new Thread(zd);//启动子弹线程t.start();}}class Zidan implements Runnable{int x;int y;int fangxiang;int sudu=8;public boolean shengming=false;public Zidan(){}public Zidan(int x,int y,int fangxiang,boolean shengming){this.x=x;this.y=y;this.fangxiang=fangxiang;this.shengming=shengming;}public void run(){while(true){try{Thread.sleep(50);//凡是线程下的死循环，都要有个睡眠}catch(Exception e){}switch(fangxiang){case 0:y-=sudu;break;case 1:x-=sudu;break;case 2:y+=sudu;break;case 3:x+=sudu;break;}if(x<0 ||y<0 ||x>800 ||y>600){this.shengming=false;break;}//System.out.println("线程2");}}}class DiTank extends Tank implements Runnable{Zidan zd=new Zidan();public DiTank(int x,int y){super(x,y);}public void run(){while(this.shengming=true){try{Thread.sleep(50);}catch(Exception e){}this.fangxiang=(int)(Math.random()*4);switch(this.fangxiang){case 0:for(int i=0;i<30;i++){if(getY()-sudu<0) {break;}this.setY(this.getY()-sudu);try{Thread.sleep(50);}catch(Exception e){}}break;case 1:for(int i=0;i<30;i++)if(getX()-sudu<0) {break;}this.setX(this.getX()-sudu);try{Thread.sleep(50);}catch(Exception e){}}break;case 2:for(int i=0;i<30;i++){if(getY()+sudu>520) {break;}this.setY(this.getY()+sudu);try{Thread.sleep(50);}catch(Exception e){}}break;case 3:for(int i=0;i<30;i++){if(getX()+sudu>750) {break;}this.setX(this.getX()+sudu);try{Thread.sleep(50);}catch(Exception e){}}break;}if(this.zd.shengming==false){switch(fangxiang){case 0:zd=new Zidan(super.getX()+10,super.getY(),super.getFangxiang(),true);break;zd=new Zidan(super.getX(),super.getY()+10,super.getFangxiang(),true);break;case 2:zd=newZidan(super.getX()+10,super.getY()+30,super.getFangxiang(),true);break;case 3:zd=newZidan(super.getX()+30,super.getY()+10,super.getFangxiang(),true);break;}Thread t=new Thread(zd);t.start();}}}}class shengyin extends Thread//播放声音的类{private String wjm;public shengyin(String ypwj){wjm=ypwj;}public void run(){File wjl=new File(wjm);AudioInputStream ypsrl=null;//AudioInputStream类：音频输入流try{ypsrl=AudioSystem.getAudioInputStream(wjl);}catch(Exception e){}AudioFormat format=ypsrl.getFormat();SourceDataLine aqsj=null; info=new (SourceDataLine.class,format);try{aqsj=(SourceDataLine)AudioSystem.getLine(info);aqsj.open(format);}catch(Exception e){}aqsj.start();int zjtj=0;byte[] hczj=new byte[1024];try{while(zjtj!=1){zjtj=ypsrl.read(hczj,0,hczj.length);if(zjtj>=0){aqsj.write(hczj,0,zjtj);}}}catch(Exception e){}finally{aqsj.drain();aqsj.close();}}}。

java坦克游戏双人对战版

坦克大战双人对战版班级：姓名：yangxixi 学号：任务：游戏设计，代码书写，调试班级：姓名：学号：任务：代码调试，美工一、游戏介绍：本游戏实现坦克大战双人对战，添加了超级炮弹，增加友军数量，复活等选项。

目前是单机版，网络版代码目前已实现联网对战。

P1玩家：WASD控制移动方向，F发射子弹，G发射超级炮弹，Q复活E增加5个友军，B清空；P2玩家：上下左右方向键控制移动方向，Ctrl发射子弹，I发射超级炮弹，O 复活P增加5个友军，B清空；二．设计思路：1.画出主窗口，坦克，实现自己坦克八个方向的移动:通过对按键监听，判断出坦克移动方向，再根据方向改变坦克位置，实现坦克的移动；2.产生敌人坦克：改变坦克好坏变量，增加敌人坦克；3.加入子弹，能够打击敌人：增加子弹类，封装所需信息，在合适位置创建子弹类对象；4.让敌人能够移动：用随机数产生器给坦克增加随机的方向，子弹；5.加入爆炸：增加爆炸类，在合适的地方创建对象；6.加入墙，解决碰撞问题：增加墙类，在合适的地方创建对象；7.加入血块：增加血块类，在合适的地方创建对象；加入血量显示：在我的坦克位置上方画出血量；8.添加超级炮弹，加入键位控制。

9.加入图片：加入图片让游戏更加美观。

10.加入另一两主战坦克，实现双人对战:产生另一辆坦克，以your变量区分，增加键盘控制;三．关键代码TankClient.java,Tank.java, Wall.java,Missile.java,Explode.java Blood.java一共6个java文件，其他每个类都拿到一个TankClient类的引用，方便对其变量，常量，方法的调用。

1.首先添加窗口关闭事件处理信息，固/*** 这个方法画出游戏的主窗口*/publicvoid launchFrame() {for(int i=0;i<5;i++){this.tanks.add(newTank(50+(i+1)*40,50,false,false,false,this));}this.setBounds(Startx, Starty,Image_Width,Image_LENGTH);this.setTitle("TankWar");this.setBackground(Color.black);this.setVisible(true);this.setResizable(false);/*** 添加窗口关闭监听*/this.addWindowListener(new WindowAdapter() {publicvoid windowClosing(WindowEvent e) {sw=false;System.exit(0);}重写paint方法，负责画出坦克，画出时只需调用坦克的draw方法（体现面向对象思维），意味着新建tank类，用于封装坦克信息，暂时用实心圆表示坦克，重写update方法，将坦克图像先画到一张图片上再画到屏幕上：myTank.draw(g);yourTank.draw(g);w1.draw(g);w2.draw(g);w3.draw(g);w4.draw(g);b.draw(g);publicvoid update(Graphics g) {if(offScreenImage==null){offScreenImage=this.createImage(Image_Width,Image_LENGTH);}Graphics goffScreen=offScreenImage.getGraphics();Color c=goffScreen.getColor();goffScreen.setColor(new Color(139, 139, 0));goffScreen.fillRect(0, 0, Image_Width,Image_LENGTH);paint(goffScreen);g.drawImage(offScreenImage, 0, 0, null);}接下来创建一个新的线程类，每隔80ms重画一次，当坦克的位置改变时，画面中就会出现坦克的移动，repaint方法会自动调用paint方法：publicclass PaintThread implements Runnable{/*** 重写run方法*/publicvoid run() {while(sw){repaint();try {Thread.sleep(80);} catch (InterruptedException e) {e.printStackTrace();}}接下来让坦克听从我们的指挥移动，添加键盘监听器类KeyMonitor，在tank 类中添加move方法及方向属性，move方法根据坦克方向改变坦克位置：case L:x -= x_SPEED;break;case LU:x -= x_SPEED;y -= y_SPEED;break;case U:y -= y_SPEED;break;case UR:x += x_SPEED;y -= y_SPEED;break;case R:x += x_SPEED;break;case RD:x += x_SPEED;y += y_SPEED;break;case D:y += y_SPEED;break;case LD:x -= x_SPEED;y += y_SPEED;break;case STOP:break;default:而在监听类中，先根据键盘读出上下左右（由keypressed方法完成），再判断是否有两个方向同时被按下（locateDirections方法完成）：publicvoid keyPressed(KeyEvent e) {int key = e.getKeyCode();switch (key) {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;default:break;}locateDirections();publicvoid locateDirections() {if (bL&& !bU&& !bR&& !bD)dir = Directions.L;if (bL&&bU&& !bR&& !bD)dir = Directions.LU;if (!bL&&bU&& !bR&& !bD)dir = Directions.U;if (!bL&&bU&&bR&& !bD)dir = Directions.UR;if (!bL&& !bU&&bR&& !bD)dir = Directions.R;if (!bL&& !bU&&bR&&bD)dir = Directions.RD;if (!bL&& !bU&& !bR&&bD)dir = Directions.D;if (bL&& !bU&& !bR&&bD)dir = Directions.LD;if (!bL&& !bU&& !bR&& !bD)dir = Directions.STOP;TankCient添加键盘监听器，针对不同的键改变坦克的位置，与重画线程结合产生不同方向运动：publicvoid keyPressed(KeyEvent e) {myTank.keyPressed(e);yourTank.keyPressed1(e);addEnemTanks(e);addMyTanks(e);addMineTanks(e);cleanAll(e);superMissile(e);}这样我们就实现流坦克根据键盘按键向八个方向移动。

坦克大战java

Java坦克大战图片版V3.4（加入各种类型墙的图片）【严重模仿90坦克】作者:Magci 日期:2008-04-25 06:49 PM字体大小: 小中大3.4版更新内容：加入各种类型墙的图片：1.石墙：炮弹、坦克都不能穿透；1.砖墙：炮弹能打掉，坦克不能穿透；3.河流：炮弹能穿透，坦克不能穿透；4.草地：炮弹、坦克都能穿透。

TankClient.java:程序代码package .ahau.mgc.tankwar;import java.awt.*;import java.awt.event.*;import java.util.*;import java.util.List;/*** 此类用于创建游戏窗体* @author Magci**/public class TankClient extends Frame {public static final int WINDOW_Y = 100;/*** 窗体宽度*/public static final int WINDOW_WIDTH = 800; /*** 窗体高度*/public static final int WINDOW_HEIGHT = 600; /*** 坦克起始位置左上角X坐标*/public static final int Tank_X = 400;/*** 坦克起始位置左上角Y坐标*/public static final int Tank_Y = 540;/*** 窗体刷新率*/public static final int REFRESH_RATE = 50; /*** 墙起始点X坐标*/public static final int WALL_X = 4;/*** 墙起始点Y坐标*/public static int WALL_Y = 75;//窗体左上角X坐标private int windowX = 0;//窗体左上角Y坐标private int windowY = 0;//敌方坦克总数量private int tankAllNum;//敌方坦克同时出现的最大数量private int tankMaxNum;//当前敌方坦克数量private int tankNum = 0;//我方坦克总数量private int myTankNum;//用于双缓冲的图片Image offScreenImage = null;//我方坦克Tank myTank = null;//存放敌方坦克的容器List<Tank> enemyTanks = new ArrayList<Tank>();//存放炮弹的容器List<Missile> missiles = new ArrayList<Missile>();//存放爆炸的容器List<Explode> explodes = new ArrayList<Explode>();//存放爆炸的容器List<Wall> walls = new ArrayList<Wall>();//宝物Treasure trea = null;//用于生成随机数Random rand = new Random();public static void main(String[] args) {// 创建一个窗体new TankClient("TankClient", 20, 5, 3);}/*** 根据标题，敌我坦克数量创建一个窗体* @param title 窗体标题* @param tankAllNum 敌方坦克总数量* @param tankMaxNum 敌方坦克同时出现的最大数量* @param myTankNum 我方坦克总数量*/public TankClient(String title, int tankAllNum, int tankMaxNum, int myTankNum) { super(title);this.tankAllNum = tankAllNum;this.tankMaxNum = tankMaxNum;this.myTankNum = myTankNum;windowX = Integer.parseInt(PropertyMgr.getProperty("windowX"));windowY = Integer.parseInt(PropertyMgr.getProperty("windowY"));this.setBounds(windowX, windowY, WINDOW_WIDTH, WINDOW_HEIGHT); this.setResizable(false);this.setBackground(Color.BLACK);this.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {setVisible(false);System.exit(0);}});this.addKeyListener(new KeyMonitor());this.setVisible(true);myTank = new Tank(Tank_X, Tank_Y, 4, true, this);//加入敌方坦克for (int i = 0; i < tankMaxNum; i++) {Tank enemyTank = new Tank(22 + 180 * i, 40, 4, false, this);enemyTanks.add(enemyTank);this.tankNum ++;}//加入墙String sytle = null;for (int i = 0; i < 29; i++) {for (int j = 0; j < 44; j++) {if (i == 0) {if (j % 10 == 1 || j % 10 == 2) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "stone", this); walls.add(wall);}}if (i > 0 && i < 10) {if (j != 4 && j != 5 && j != 20 && j != 21 && j != 39 && j != 40) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "tile", this); walls.add(wall);}}if (i >= 10 && i < 12) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "grass", this);walls.add(wall);}if (i >= 12 && i < 14) {if (j > 10 && j < 34) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "river", this); walls.add(wall);} else {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "grass", this); walls.add(wall);}}if (i >= 14 && i < 16) {if (j == 0 || j == 1 || j == 42 || j == 43) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "stone", this); walls.add(wall);}}if (i >= 16 && i < 18) {if (j % 8 < 4) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "stone", this); walls.add(wall);}}if (i >= 18 && i < 25) {if (j % 10 < 8) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "tile", this); walls.add(wall);}}if (i >= 25 && i < 29) {if (j < 8) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "grass", this); walls.add(wall);}if (j > 35) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "river", this); walls.add(wall);}if (i > 26 && (j == 16 || j == 17 || j == 28 || j == 29)) {Wall wall = new Wall(WALL_X + j * 18, WALL_Y + i * 18, "tile", this); walls.add(wall);}}}}// 启动重画线程PaintThread pt = new PaintThread();Thread t = new Thread(pt);t.start();}/*** 在窗体中画出游戏界面*/public void paint(Graphics g) {if (this == null)return;Color c = g.getColor();g.setColor(Color.RED);if (!myTank.isLive()) {if (-- this.myTankNum > 0) {myTank = new Tank(Tank_X, Tank_Y, 4, true, this); } else {g.drawString("GameOver!", 350, 280);g.drawString("按F2键重新开始..", 340, 300);return;}}if (tankAllNum == 0) {g.drawString(".:恭喜过关!:.", 350, 280);g.drawString("按F2键重新开始..", 340, 300);return;}g.setColor(c);this.reinforceTank();this.drawMissiles(g);this.drawMyTank(g);this.drawEnemyTanks(g);this.drawWalls(g);this.drawExplodes(g);this.drawTreasure(g);this.drawMessage(g);}/*** 重写update方法,先将窗体上的图形画在图片对象上，再一次性显示*/public void update(Graphics g) {if (offScreenImage == null) {offScreenImage = this.createImage(WINDOW_WIDTH, WINDOW_HEIGHT); }Graphics gImage = offScreenImage.getGraphics();Color c = gImage.getColor();gImage.setColor(Color.BLACK);gImage.fillRect(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);gImage.setColor(c);paint(gImage);g.drawImage(offScreenImage, 0, 0, null);}/*** 用线程重画，每隔一段时间重画窗体* @author Magci**/private class PaintThread implements Runnable {/*** 每隔REFRESH_RATE毫秒重画一次窗体*/public void run() {while (true) {repaint();try {Thread.sleep(REFRESH_RATE);} catch (InterruptedException e) {e.printStackTrace();}}}}/*** 监听键盘事件，按方向键控制坦克移动* @author Magci**/private class KeyMonitor extends KeyAdapter {/*** 处理按键被按下事件*/public void keyPressed(KeyEvent e) {myTank.keyPressed(e);}/*** 处理按键被松开事件*/public void keyReleased(KeyEvent e) {myTank.keyReleased(e);}}/*** 敌方坦克增援*/public void reinforceTank() {if (tankNum < tankMaxNum && tankAllNum > tankNum) {int i = rand.nextInt(10);Tank enemyTank = new Tank(50 + 150 * i, 40, 4, false, this);if (!enemyTank.collidesWithTank(myTank, true) && !enemyTank.collidesWithTanks (enemyTanks, true)) {enemyTanks.add(enemyTank);this.tankNum ++;}}}/*** 加入墙* @param g Graphics对象*/public void drawWalls(Graphics g) {for (int i = 0; i < walls.size(); i++) { Wall wall = walls.get(i);wall.draw(g);}}/*** 画我方坦克* @param g Graphics对象*/public void drawMyTank(Graphics g) { if (myTank != null) {myTank.draw(g);if (trea != null)myTank.eatTreasure(trea);}}/*** 画敌方坦克* @param g Graphics对象*/public void drawEnemyTanks(Graphics g) {for (int i = 0; i < enemyTanks.size(); i++) {Tank enemyTank = enemyTanks.get(i);enemyTank.draw(g);enemyTank.collidesWithTank(myTank, false);enemyTank.collidesWithTanks(enemyTanks, false); }}/*** 画炮弹* @param g Graphics对象*/public void drawMissiles(Graphics g) {for (int i = 0; i < missiles.size(); i++) {Missile m = missiles.get(i);if (m != null) {m.draw(g);m.hitTanks(enemyTanks);m.hitTank(myTank);m.hitMissiles(missiles);}}}/*** 加入爆炸* @param g Graphics对象*/public void drawExplodes(Graphics g) {for (int i=0; i < explodes.size(); i++) { Explode e = explodes.get(i);e.draw(g);}}/*** 出现宝物* @param g Graphics对象*/public void drawTreasure(Graphics g) {if (rand.nextInt(100) == 0)trea = null;if (rand.nextInt(300) == 0) {int x = rand.nextInt(785);int y = rand.nextInt(555);trea = new Treasure(x, y, this);}if (trea != null) {trea.collidesWithWalls(walls);trea.draw(g);}}/*** 打印信息* @param g Graphics对象*/public void drawMessage(Graphics g) {Color c = g.getColor();g.setColor(Color.YELLOW);g.drawString("EnemyTanks Count: " + enemyTanks.size(), 10, 50);g.drawString("All EnemyTanks Count: " + this.tankAllNum, 10, 70);g.drawString("MyTank Count: " + this.myTankNum, 10, 90);g.drawString("MyTank Life: " + myTank.getLife(), 10, 110);g.setColor(c);}/*** 返回敌方坦克总数量* @return 敌方坦克总数量*/public int getTankAllNum() {return tankAllNum;}/*** 设置敌方坦克总数量* @param tankAllNum 敌方坦克总数量*/public void setTankAllNum(int tankAllNum) {this.tankAllNum = tankAllNum;}/*** 返回当前敌方坦克数量* @return 返回当前敌方坦克数量*/public int getTankNum() {return tankNum;}/*** 设置当前敌方坦克数量* @param tankNum 当前敌方坦克数量*/public void setTankNum(int tankNum) { this.tankNum = tankNum;}}Tank.java:程序代码package .ahau.mgc.tankwar; import java.awt.*;import java.awt.event.*;import java.util.*;import java.util.List;/*** 此类用于创建一个坦克* @author Magci**/public class Tank {/*** 坦克水平垂直移动时X、Y轴上的速度*/public static final int SPEED = 4;/*** 坦克45度移动时X、Y轴上的速度*/public static final int XYSPEED = (int) (Math.sqrt(2) * SPEED / 2); /*** 坦克的宽度*/public static final int WIDTH = 30;/*** 坦克的高度*/public static final int HEIGHT = 30;/*** 炮筒长度*/public static final int PT_LENGTH = 20;/*** 45度炮筒的X、Y坐标偏移量*/public static final int PT_XY = (int) (Math.sqrt(2) * PT_LENGTH) / 2; /*** 坦克初始生命值*/public static final int LIFE = 100;// 坦克左上角位置private int x, y;// 标记方向键的状态：true表示被按下，false表示被松开private boolean bL = false, bU = false, bR = false, bD = false;/*** 坦克方向*/public Direction dir = Direction.STOP;/*** 坦克炮筒方向*/public Direction ptDir = Direction.U;TankClient tc = null;//标记敌我坦克，true表示我方坦克，false表示敌方坦克private boolean good;//标记坦克生命状态private boolean live = true;private Random rand = new Random();//地方坦克改变一次方向需要的步数private int step = rand.nextInt(10) + 3;//坦克的上一个位置private int lastX = -1, lastY = -1;//坦克的生命值private int life = LIFE;//坦克生命条LifeBar lb = new LifeBar();//方向数private int dirNum = 8;//判断是否初始化private boolean init = false;private static Toolkit tk = Toolkit.getDefaultToolkit();private static Image[] tankImgs;private static Map<String,Image> imgs = new HashMap<String,Image>();static {tankImgs = new Image[] {tk.getImage(Tank.class.getClassLoader().getResource("images/myTankL.gif")),tk.getImage(Tank.class.getClassLoader().getResource("images/myTankU.gif")),tk.getImage(Tank.class.getClassLoader().getResource("images/myTankR.gif")),tk.getImage(Tank.class.getClassLoader().getResource("images/myTankD.gif")),tk.getImage(Tank.class.getClassLoader().getResource("images/enemyTankL.gif")), tk.getImage(Tank.class.getClassLoader().getResource("images/enemyTankU.gif")), tk.getImage(Tank.class.getClassLoader().getResource("images/enemyTankR.gif")),tk.getImage(Tank.class.getClassLoader().getResource("images/enemyTankD.gif")) };imgs.put("myTankL", tankImgs[0]);imgs.put("myTankU", tankImgs[1]);imgs.put("myTankR", tankImgs[2]);imgs.put("myTankD", tankImgs[3]);imgs.put("enemyTankL", tankImgs[4]);imgs.put("enemyTankU", tankImgs[5]);imgs.put("enemyTankR", tankImgs[6]);imgs.put("enemyTankD", tankImgs[7]);}/*** 根据坦克位置和敌我状态创建一个坦克* @param x 坦克左上角X坐标* @param y 坦克左上角Y坐标* @param good 坦克的敌我状态*/public Tank(int x, int y, boolean good) {this.x = x;this.y = y;this.good = good;}/*** 根据坦克位置，敌我状态和当前游戏窗体创建一个坦克* @param x 坦克左上角X坐标* @param y 坦克左上角Y坐标* @param good 坦克的敌我状态* @param tc 当前游戏窗体*/public Tank(int x, int y, boolean good, TankClient tc) {this(x, y, good);this.tc = tc;}/*** 根据坦克位置，敌我状态和当前游戏窗体创建一个坦克* @param x 坦克左上角X坐标* @param y 坦克左上角Y坐标* @param dirNum 方向数* @param good 坦克的敌我状态* @param tc 当前游戏窗体*/public Tank(int x, int y, int dirNum, boolean good, TankClient tc) { this(x, y, good, tc);this.dirNum =dirNum;}/*** 在窗体上画出坦克* @param g Graphics对象*/public void draw(Graphics g) {if (!this.live) {if (!this.good)tc.enemyTanks.remove(this);tc.setTankNum(tc.getTankNum() - 1);tc.setTankAllNum(tc.getTankAllNum() - 1); return;}Color c = g.getColor();if (good)g.setColor(Color.RED);elseg.setColor(Color.BLUE);this.drawTank(g);if (good)lb.draw(g);g.setColor(c);//敌方坦克定位if (!good) {if (step == 0) {Direction[] dirs = Direction.values();int i = rand.nextInt(5);dir = dirs[i];if (rand.nextInt(20) == 0)dir = Direction.D;step = rand.nextInt(10) + 3;}step --;if (!this.hasMyMissile())fire();}move();}/*** 方向键被按下后标记被按下的键* @param e 键盘事件*/public void keyPressed(KeyEvent e) { int keyCode = e.getKeyCode();switch (keyCode) {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_CONTROL:if (!this.hasMyMissile())fire();break;case KeyEvent.VK_A:superFire();break;case KeyEvent.VK_F2:tc = new TankClient("TankClient", 50, 10, 3); break;}locateDirection();}/*** 方向键被松开后标记被松开的键* @param e 键盘事件*/public void keyReleased(KeyEvent e) {int keyCode = e.getKeyCode();switch (keyCode) {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 void locateDirection() {if (dirNum == 4 || dirNum ==8) { if (bL && !bU && !bR && !bD) dir = Direction.L;if (!bL && bU && !bR && !bD) dir = Direction.U;if (!bL && !bU && bR && !bD) dir = Direction.R;if (!bL && !bU && !bR && bD) dir = Direction.D;}if (dirNum == 8) {if (bL && bU && !bR && !bD)dir = Direction.LU;if (!bL && bU && bR && !bD)dir = Direction.RU;if (!bL && !bU && bR && bD)dir = Direction.RD;if (bL && !bU && !bR && bD)dir = Direction.LD;}if (!bL && !bU && !bR && !bD) dir = Direction.STOP;}/*** 根据方向移动坦克*/public void move() {lastX = x;lastY = y;switch (dir) {case L:x -= SPEED;break;case LU:x -= XYSPEED;y -= XYSPEED;break;case U:y -= SPEED;break;case RU:x += XYSPEED;y -= XYSPEED;break;case R:x += SPEED;break;case RD:x += XYSPEED;y += XYSPEED;break;case D:y += SPEED;break;case LD:x -= XYSPEED;y += XYSPEED;break;case STOP:break;}if (dir != Direction.STOP)ptDir = dir;//控制坦克不出界if (x < 0)x = 0;if (y < 30)y = 30;if (x > TankClient.WINDOW_WIDTH - this.WIDTH) x = TankClient.WINDOW_WIDTH - this.WIDTH; if (y > TankClient.WINDOW_HEIGHT - this.HEIGHT) y = TankClient.WINDOW_HEIGHT - this.HEIGHT; }/*** 根据坦克的位置和炮筒的方向发射炮弹*/public void fire() {int mW = 0;int mH = 0;if (!this.live)return;if (ptDir == Direction.U || ptDir == Direction.D) {mW = Missile.WIDTH / 2;mH = Missile.HEIGHT / 2;} else if (ptDir == Direction.L || ptDir == Direction.R) { mW = Missile.HEIGHT / 2;mH = Missile.WIDTH / 2;}int x = this.x + Tank.WIDTH / 2 - mW;int y = this.y + Tank.HEIGHT / 2 - mH;Missile m = new Missile(x, y, this.good, ptDir, this, tc); tc.missiles.add(m);}/*** 根据方向画坦克* @param g Graphics对象*/public void drawTank(Graphics g) {if (good) {switch (ptDir) {case L:g.drawImage(imgs.get("myTankL"), x, y, null);break;case LU:break;case U:g.drawImage(imgs.get("myTankU"), x, y, null);break;case RU:break;case R:g.drawImage(imgs.get("myTankR"), x, y, null);break;case RD:break;case D:g.drawImage(imgs.get("myTankD"), x, y, null);break;case LD:break;}} else {switch (ptDir) {case L:g.drawImage(imgs.get("enemyTankL"), x, y, null); break;case LU:break;case U:g.drawImage(imgs.get("enemyTankU"), x, y, null);break;case RU:break;case R:g.drawImage(imgs.get("enemyTankR"), x, y, null);break;case RD:break;case D:g.drawImage(imgs.get("enemyTankD"), x, y, null);break;case LD:break;}}}/*** 返回坦克的矩形碰撞区域* @return 坦克的矩形碰撞区域*/public Rectangle getRect() {Rectangle rect = new Rectangle(x, y, this.WIDTH, this.HEIGHT); return rect;}/*** 返回坦克的生命状态* @return 坦克的生命状态*/public boolean isLive() {return live;}/*** 设置坦克的生命状态* @param live 坦克的生命状态*/public void setLive(boolean live) { this.live = live;}/*** 返回坦克的敌我状态* @return 坦克的敌我状态*/public boolean isGood() {return good;}/*** 设置坦克的方向* @param dir 坦克的方向*/public void setDir(Direction dir) {this.dir = dir;}/*** 坦克回到上一个位置*/public void stay() {if (x != -1 && y != -1) {this.x = stX;this.y = stY;} else {tc.enemyTanks.remove(this);tc.setTankAllNum(tc.getTankAllNum() - 1);tc.setTankNum(tc.getTankNum() - 1);}}/*** 判断是否与其他坦克相撞* @param t 坦克* @param newTank 是否新坦克* @return 坦克是否与其他坦克相撞*/public boolean collidesWithTank(Tank t, boolean newTank) {if (this.live && t.isLive() && t != this && this.getRect().intersects(t.getRect())) { if (!newTank) {this.stay();t.stay();}return true;}return false;}/*** 依次判断其他所有坦克是否与该坦克相撞* @param tanks 存放坦克的容器* @param newTank 是否新坦克* @return 坦克是否与其他坦克相撞*/public boolean collidesWithTanks(List<Tank> tanks, boolean newTank) { for (int i = 0; i < tanks.size(); i++) {Tank t = tanks.get(i);this.collidesWithTank(t, newTank);}return false;}/*** 发射超级炮弹（四个方向同时开火）*/public void superFire() {if (!this.live)return;int x = 0, y = 0, mW = 0, mH = 0;Direction[] dirs = Direction.values();for (int i = 0; i < 5; i++) {if (ptDir == Direction.U || ptDir == Direction.D) {mW = Missile.WIDTH / 2;mH = Missile.HEIGHT / 2;} else if (ptDir == Direction.L || ptDir == Direction.R) { mW = Missile.HEIGHT / 2;mH = Missile.WIDTH / 2;}x = this.x + Tank.WIDTH / 2 - mW;y = this.y + Tank.HEIGHT / 2 - mH;if (dirs[i] != Direction.STOP) {Missile m = new Missile(x, y, this.good, dirs[i], this, tc); tc.missiles.add(m);}}}/*** 返回坦克的生命值* @return 坦克的生命值*/public int getLife() {return life;}/*** 设置坦克的生命值* @param life 坦克的生命值*/public void setLife(int life) {this.life = life;}/*** 创建生命条* @author Magci**/class LifeBar {/*** 在坦克上方画生命条* @param g Graphics对象*/public void draw(Graphics g) {Color c = g.getColor();g.setColor(Color.RED);g.drawRect(x, y - 10, WIDTH, 5);g.fillRect(x, y - 10, WIDTH * life / 100, 5);g.setColor(c);}}/*** 判断坦克是否碰到宝物* @param trea 宝物* @return 坦克是否碰到宝物*/public boolean eatTreasure(Treasure trea) {if (this.live && trea.isLive() && this.getRect().intersects(trea.getRect())) { trea.setLive(false);this.life = LIFE;return true;}return false;}/*** 返回坦克左上角X坐标* @return 坦克左上角X坐标*/public int getX() {return x;}/*** 设置坦克左上角X坐标* @param x*/public void setX(int x) {this.x = x;}/*** 返回坦克左上角Y坐标* @return 坦克左上角Y坐标*/public int getY() {return y;}/*** 设置坦克左上角Y坐标* @param y 坦克左上角Y坐标*/public void setY(int y) {this.y = y;}/*** 判断是否有该坦克发射的炮弹* @return 是否有该坦克发射的炮弹*/public boolean hasMyMissile() {for (int i = 0; i < tc.missiles.size(); i++) { Missile m = tc.missiles.get(i);if (m.getT() == this)return true;}return false;}}Missile.java:程序代码package .ahau.mgc.tankwar; import java.awt.*;import java.util.List;import java.util.*;/*** 此类用于创建炮弹* @author Magci**/public class Missile {/*** 炮弹宽度*/public static final int WIDTH = 30; /*** 炮弹长度*/public static final int HEIGHT = 30; /*** 炮弹水平垂直发射时X、Y轴上的速度 */public static final int SPEED = 15;/*** 炮弹45度发射时X、Y轴上的速度*/public static final int XYSPEED = (int) (Math.sqrt(2) * SPEED / 2);// 炮弹左上角位置private int x, y;Direction ptDir;TankClient tc = null;Tank t;//标记炮弹是否存在private boolean live = true;//标记炮弹的敌我状态private boolean good;//标记是否初始化private boolean init = false;private static Toolkit tk = Toolkit.getDefaultToolkit();private static Image[] missileImgs;private static Map<String, Image> imgs = new HashMap<String, Image>();static {missileImgs = new Image[] {tk.getImage(Missile.class.getClassLoader().getResource("images/missileL.gif")), tk.getImage(Missile.class.getClassLoader().getResource("images/missileU.gif")), tk.getImage(Missile.class.getClassLoader().getResource("images/missileR.gif")), tk.getImage(Missile.class.getClassLoader().getResource("images/missileD.gif")) };imgs.put("L",missileImgs[0]);imgs.put("U",missileImgs[1]);imgs.put("R",missileImgs[2]);imgs.put("D",missileImgs[3]);}/*** 根据坦克位置、炮筒方向、坦克敌我状态、发射炮弹的坦克、当前窗体创建炮弹* @param x 坦克中心X坐标* @param y 坦克中心Y坐标* @param good 坦克敌我状态* @param ptDir 炮筒方向* @param t 发射炮弹的坦克* @param tc 当前窗体*/public Missile(int x, int y, boolean good, Direction ptDir, Tank t, TankClient tc) { this.x = x;this.y = y;this.good = good;this.ptDir = ptDir;this.t = t;this.tc = tc;}/*** 在窗体上画出炮弹* @param g Graphics对象*/public void draw(Graphics g) {if (!this.live) {tc.missiles.remove(this);return;}if (!init) {for(int i = 0; i < missileImgs.length; i++)g.drawImage(missileImgs[i], -100, -100, null); init = true;}Color c = g.getColor();if (this.good)g.setColor(Color.RED);elseg.setColor(Color.BLACK);this.drawMissile(g);g.setColor(c);move();}/*** 根据炮筒方向发射炮弹*/public void move() {switch (ptDir) {case L:x -= SPEED;break;case LU:x -= XYSPEED; y -= XYSPEED; break;case U:y -= SPEED;break;case RU:x += XYSPEED; y -= XYSPEED; break;case R:x += SPEED; break;case RD:x += XYSPEED; y += XYSPEED; break;case D:y += SPEED; break;case LD:x -= XYSPEED; y += XYSPEED; break;}//判断炮弹是否出界if (x < 0 || x > TankClient.WINDOW_WIDTH || y < 0 || y > TankClient.WINDOW_HE IGHT) {live = false;}}/*** 返回炮弹的矩形碰撞区域* @return 炮弹的矩形碰撞区域*/public Rectangle getRect() {int w = 0, h = 0;if (ptDir == Direction.U || ptDir == Direction.D) {w = this.WIDTH;h = this.HEIGHT;} else if (ptDir == Direction.L || ptDir == Direction.R) {w = this.HEIGHT;h = this.WIDTH;}Rectangle rect = new Rectangle(x, y, w, h);return rect;}/*** 判断是否击中坦克* @param t 坦克* @return 是否击中坦克*/public boolean hitTank(Tank t) {if (this.getRect().intersects(t.getRect()) && t.isLive() && this.live && t.isGood() != thi s.good) {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;}/*** 依次判断所有的敌方坦克是否被该炮弹击中* @param enemyTanks 敌方坦克* @return 否击中敌方坦克*/public boolean hitTanks(List<Tank> enemyTanks) {for (int i = 0; i < enemyTanks.size(); i++) {Tank enemyTank = enemyTanks.get(i);if (hitTank(enemyTank))return true;}return false;}/*** 设置炮弹左上角的X坐标* @return 炮弹左上角的X坐标*/public int getX() {return x;}/*** 设置炮弹左上角的Y坐标* @return 炮弹左上角的Y坐标*/public int getY() {return y;}/*** 判断炮弹是否击中对方炮弹* @param m 炮弹* @return 炮弹是否击中对方炮弹*/public boolean hitMissile(Missile m) {if (this.live && m.isLive() && this.good != m.isGood() && this.getRect().intersects(m. getRect())) {this.live = false;m.setLive(false);return true;}return false;}/*** 依次判断对方所有的炮弹是否被该炮弹击中* @param missiles 存放炮弹的容器* @return 炮弹是否击中对方炮弹*/public boolean hitMissiles(List<Missile> missiles) { for (int i = 0; i < missiles.size(); i++) {Missile m = missiles.get(i);if (hitMissile(m))return true;}return false;}/*** 返回炮弹的敌我状态* @return 炮弹的敌我状态*/public boolean isGood() {return good;}/*** 返回炮弹的生命状态* @return 炮弹的生命状态*/public boolean isLive() {return live;}/*** 设置炮弹的生命状态* @param live 炮弹的生命状态*/public void setLive(boolean live) { this.live = live;}/*** 返回发射该炮弹的坦克* @return 发射该炮弹的坦克*/public Tank getT() {return t;}/*** 根据方向画炮弹* @param g Graphics对象*/public void drawMissile(Graphics g) {switch (ptDir) {case L:g.drawImage(imgs.get("L"), x, y, null); break;case LU:break;case U:g.drawImage(imgs.get("U"), x, y, null); break;case RU:break;case R:g.drawImage(imgs.get("R"), x, y, null); break;case RD:break;case D:g.drawImage(imgs.get("D"), x, y, null); break;case LD:break;}}}Explode.java:程序代码package .ahau.mgc.tankwar;import java.awt.*;/*** 此类用于创建爆炸* @author Magci**/public class Explode {private int x, y;private int step = 0;private boolean live = true;private int radius = 10;TankClient tc;private static Toolkit tk = Toolkit.getDefaultToolkit();private static Image[] imgs = {tk.getImage(Explode.class.getClassLoader().getResource("images/0.gif")), tk.getImage(Explode.class.getClassLoader().getResource("images/1.gif")), tk.getImage(Explode.class.getClassLoader().getResource("images/2.gif")), tk.getImage(Explode.class.getClassLoader().getResource("images/3.gif")), tk.getImage(Explode.class.getClassLoader().getResource("images/4.gif")), tk.getImage(Explode.class.getClassLoader().getResource("images/5.gif"))。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

基于java坦克大战游戏的设计采用了java语言面向对象的思想，在设计的过程中，游戏的所有物体都赋予对象的概念和属性。

本游戏的设计是在玩家进行游戏时，通过上下左右键来控制坦克，并且打出炮弹，以消灭所有敌人为游戏目的。

在游戏过程中，敌方的坦克也会智能化的躲避玩家打出来的子弹。

通过游戏的设计，是对java语言一个方便灵活运用的体现。

关键字：网络科技 java 面向对象智能化Based on the development of Java language Tank WarsGameAbstractWith the continuous development of network technology, the emergence of our life changes, especially in the game this piece, there has been an unprecedented prosperity, all kinds of games to enter our life, and the original "Tetris", "Tank Wars", "greedy eat snake" and other classic games have been many people know, is how many 80 or even 90 after the talk.Based on the design of the Java Tank Wars game using java language for the object of thought, in the process of design, the game of all objects are given the concept of the object and attribute. The game's design is in the game, the players, through the upper and lower keys to control the tank, and hit the shell, to destroy all the enemies for the purpose of the game. In the course of the game, the enem y's tanks will also be intelligent to escape the players to play out the bullet. Through the game design, is a convenient and flexible use of Java language.Keywords: network technology, Java, object-oriented, intelligent第一章游戏简要说明《坦克大战》作为曾经风靡全球的一款FC游戏，可谓是曾经经典中的经典，其极为出色的游戏性令全球众多玩家为之疯狂，更是多少80后甚至90后津津乐道的游戏之一。

《坦克大战》是一款以红白机为平台操作设计游戏。

玩家通过控制自己的坦克进行射击，以击毁敌方坦克为目的，每个关卡中有着不同的地形和障碍物，玩家可以利用地形中的障碍物进行射击，障碍物可以阻挡敌方的坦克的子弹，同时，也可以阻挡玩家自身打出来的子弹。

因此在游戏中，玩家要利用好地图中的障碍物，来保障自身的安全，以达到消灭敌军的目的。

在游戏中，还设置了有各种各样的补给。

游戏中坦克能向八个方向移动和开炮，并且坦克与坦克之间不可相互穿越。

坦克打出来的炮弹若击中对方，就会产生爆炸现象。

玩家的坦克不仅有生命值，而且还有生命个数，当玩家坦克遭到敌方坦克子弹的击打之后，玩家坦克的生命值就会减少，当玩家坦克的生命值减到0时，玩家的坦克就爆炸，同时也会减少一辆坦克数量，玩家也可以通过地图上随机出现的血块来增加自己的血量。

当玩家消灭所有的敌方坦克的时候，此时游戏结束；若玩家的坦克被打死，可以按F2键进行开始新的游戏。

其操作简单且娱乐性强，是一款男女老少皆宜的游戏。

游戏附带地图编辑器，玩家可自行编辑地图进行游戏。

游戏中的众多经典关卡至今还让许多玩家记忆犹新，在80年代时曾经在无数家庭中带来了无尽的欢乐。

第二章开发环境介绍2.1 开发环境操作系统：win8.1开发语言：java开发工具：Eclipse2.2 java语言特点简介（1）简单java语言的语法很简单，容易掌握，并且它是纯面向对象的语言。

Java 语言的简单性可以在下面几点体现出来：1.1语言的语法与C++很相似，从某种角度上说，java是C和C++转变来的，因此，学过C语言的人员可以很轻松的掌握java的语法。

1.2 java对C++语言进行了提高和简化。

如，java取消了指针，并且使用接口取代了多重继承，因指针和多重继承往往使程序变得复杂。

1.3 java提供了很多类库，API文档和第三方开发包，此外，还有丰富的基于java的开发项目，JDK已经开放源代码，学者可通过分析这些源代码，从而来提高自己的水平。

（2）面向对象面向对象是java语言的最重要的部分，同时也是java语言的基础部分，java语言本身就是一种纯面向对象的语言。

在Java语言中，提倡万物皆面向对象，语法中不能在类外面定义单独的数据和函数，简而言之，java语言最外部的函数类型是对象，所有的元素只能通过类和对象来访问。

（3）分布性Java语言的分布性包括操作分布和数据分布，操作分布是指在多个不同的主机上布置相关操作。

（4）可移植性Java语言程序具有与体系结构无关的特性，可以很方便的移植到不同型号的计算机中。

此外，java的类库中也实现了多不同平台的接口，使得这些类库可以移植。

（5）解释性Java语言程序的运行需要解释器。

任何移植了java解释器的计算机或者其他设备都可以用java字节码进行解释执行。

字节码独立于平台，他本身携带了许多编译时的信息，使得连接过程更加简单，开发过程更加迅速，更加具有探索性。

（6）安全性Java语言没有像C语言中的指针和内存释放等语法，可以有效避免非法操作内存，并且java代码要经过指针校验，代码校验等测试步骤才能运行，因此，可以很好的保护系统平台。

（7）健壮性java程序是以编写多方面的、可靠性的运用为目标的。

在编译运行时可以检查错误，消除错误。

能更好的帮助用户检测早期出现的错误。

（8）多线程多线程机制能够让程序在同一个时间点同时运行多个任务，同时相应的同步机制可以保证不同线程能够正确的共享数据。

（9）高性能java编译后的字节码是在解释器中运行的，因此它的速度比多数交互式运用程序提高了许多，此外，字节码可以在程序运行时被翻译成特定平台的机器指令，从而实现运行速度的提高。

（10）动态java语言在很多方面比C或C++更能适应发展的环境，可以动态调整库中的方法和增加变量，而客户端却不需要任何更改。

在java中进行动态调整是非常简单和直接的。

2.3 Eclipse开发工具的简介Eclipse是由IBM公司投资4000万美元开发的集成开发工具。

它是基于java语言编写，并且是开放源代码的、可扩展的，也是目前全球最流行、使用最多的java开发工具之一。

另外，IBM公司捐出Eclipse源代码，组建Eclipse联盟，它专门负责这种工具的后续开发。

Eclipse为程序员提供了很好的java程序开发环境，它的平台系统结构是在插件概念的基础上构建起来的，插件是Eclipse平台最具有特色的特征，同时也是区别于其他开发工具的特征之一。

第三章系统总体设计3.1程序功能的总和表（1）程序表的功能3.2主体模块主体是由TankClient.java文件来实现的，主要负责各个类的调用和游戏窗口的创建。

该类中的变量还有：1.游戏的高度 int GAME_HEIGHT2.游戏的宽度 int GAME_WIDTH此外，lauchFrame( )方法、paint( )方法和update( )方法也包括在该类中，其功能分别为实现显示坦克主窗口、重画时调用和使用双缓冲消除闪烁现象。

Java语言坦克大战游戏设计(附有代码和图片)

Java综合编程——坦克大战(15.1.5)

韩顺平java坦克大战1.0版本_源代码

Java语言坦克大战游戏设计附有代码和图片

JAVA课程设计 坦克大战

JAVA课程设计坦克大战含代码

Java游戏开发之坦克大战代码

JAVA课程设计坦克大战游戏(含代码)

JAVA实现经典游戏坦克大战的示例代码

java简单坦克大战制作代码

坦克大战【java项目】

坦克大战游戏编程实现

JAVA课程设计坦克大战(含代码)

java课程设计--坦克大战游戏(带源码)

Java版坦克大战游戏毕业设计

坦克大战Java代码Tank

Java课程设计——坦克大战

java 坦克大战游戏教程完整代码

java坦克游戏双人对战版

坦克大战java

JAVA课程设计坦克大战