90坦克大战快速子弹 游戏简介
90坦克大战快速子弹NES
90坦克大战快速子弹下载地址
&用手机打开
在搜索框输入 4343 即可进入下载页面。
上一游戏：
下一游戏：
相关游戏下载
90坦克大战快速子弹 游戏评论
& &评论摘要(共 17 条，得分 1391 分，平均 81 分)
[] 17 楼 hjkhjkhkjhkj 　　打分：85 分　　发表时间：
? jmhjkhkjhkj
[] 16 楼 asd 　　打分：85 分　　发表时间：
? sadfsdffasdasfsdfsdfsdgfsdgf
[] 15 楼 胬肉 　　打分：85 分　　发表时间：
? bdvdv电话说吧独角戏还是觉得叫撒你大几
[] 14 楼 asdas 　　打分：85 分　　发表时间：
? asdasfafas
　　打分：85 分　　发表时间：
[] 12 楼 triyt 　　打分：70 分　　发表时间：
? ureureureurururut
var show_checkcode =
function get_checkcode() {
var chkCodeFile = "/common/getcode.asp";
if(!show_checkcode){
if(document.getElementById("img_checkcode"))
document.getElementById("img_checkcode").innerHTML = ''
show_checkcode =
if(document.getElementById("isok_checkcode"))
document.getElementById("isok_checkcode").innerHTML = '
用户名： ！
分　值：100分
内　容： ！
通知管理员
点击获取验证码
NES游戏网[]中国免费nes游戏资源第一门户 版权所有　Copyright &
All Rights Reserved
微信公众帐号搜索“nes游戏”，即可关注本站温馨提示：易贤网小编为您整理了“HTML5实现经典坦克大战坦克乱走还能发出一个子弹”,方便广大网友查阅！
&pre name="code" class="html"&tank.html&/pre&&pre name="code" class="html"&&!DOCTYPE html&
&meta charset="utf-8"/&
&body onkeydown="getCommand();"&
&h1&hmtl5-经典的坦克大战&/h1&
&!--坦克大战的战场--&
&canvas id="tankMap" width="400px" height="300px" style="background-color:black"&&/canvas&
&span id="aa"&数据&/span&
&!--把tankGames.js引入到本页面--&
&script type="text/javascript" src="tank.js"&&/script&
&script type="text/javascript"&
//得到画布
var canvas1=document.getElementById("tankMap");
//得到绘图上下文(你可以理解是画笔)
var cxt=canvas1.getContext("2d");
//我的坦克 hero
var hero=new Hero(140,140,0,heroColor);
//定义一颗空子弹
var heroBullet=
//定义敌人的坦克(敌人的坦克有多少? 思路 : 是单个单个的定义，还是放在数组中?)
var enemyTanks=new Array();
//先死后活 ，定3个，后面我们把敌人坦克的数量，作出变量
//0-&上, 1-&右, 2-&下 3-&左
for(var i=0;i&3;i++){
//创建一个坦克
var enemyTank=new EnemyTank((i+1)*50,0,2,enmeyColor);
//把这个坦克放入数组
enemyTanks[i]=enemyT
//先调用一次
flashTankMap();
//专门写一个函数，用于定时刷新我们的作战区，把要在作战区出现的元素(自己坦克，敌人坦克，子弹，炸弹，
//障碍物...)-&游戏思想
function flashTankMap(){
//把画布清理
cxt.clearRect(0,0,400,300);
//我的坦克
drawTank(hero);
//画出自己的子弹
//子弹飞效果是怎么出现的?[答 ： 首先我们应该每隔一定时间(setInterval)就去刷新作战区,如果在刷新的时候，子弹坐标变换了，给人的感觉就是子弹在飞!]
drawHeroBullet();
//敌人的坦克
//画出所有敌人坦克
for(var i=0;i&3;i++){
drawTank(enemyTanks[i]);
//这是一个接受用户按键函数
function getCommand(){
//我怎么知道，玩家按下的是什么键
//说明当按下键后 事件---&event对象-----&事件处理函数()
var code=event.keyC//对应字母的ascii码-&我们看码表
switch(code){
case 87://上
hero.moveUp();
hero.moveRight();
hero.moveDown();
hero.moveLeft();
hero.shotEnemy();
//触发这个函数 flashTankMap();
flashTankMap();
//重新绘制所有的敌人的坦克.你可以在这里写代码(思想,我们干脆些一个函数，专门用于定时刷新我们的画布[作战区])
//每隔100毫秒去刷新一次作战区
window.setInterval("flashTankMap()",100);
&/html&&/pre&
&pre&&/pre&
&pre name="code" class="html"&&pre name="code" class="javascript"&//为了编程方便，我们定义两个颜色数组
var heroColor=new Array("#BA9658","#FEF26E");
var enmeyColor=new Array("#00A2B5","#00FEFE");
//其它的敌人坦克，这里的扩展性，还是不错的.
function Bullet(x,y,direct,speed){
this.direct=
this.speed=
this.timer=
this.isLive=
this.run=function run(){
//在该表这个子弹的坐标时，我们先判断子弹是否已经到边界
if(this.x&=0||this.x&=400||this.y&=0||this.y&=300){
//子弹要停止.
window.clearInterval(this.timer);
//子弹死亡
this.isLive=
//这个可以去修改坐标
switch(this.direct){
this.y-=this.
this.x+=this.
this.y+=this.
this.x-=this.
document.getElementById("aa").innerText="子弹x="+this.x+" 子弹y="+this.y;
//这是一个Tank类
function Tank(x,y,direct,color){
this.speed=1;
this.direct=
//一个坦克，需要两个颜色.
this.color=
this.moveUp=function(){
this.y-=this.
this.direct=0;
this.moveRight=function(){
this.x+=this.
this.direct=1;
this.moveDown=function(){
this.y+=this.
this.direct=2;
this.moveLeft=function(){
this.x-=this.
this.direct=3;
//定义一个Hero类
//x 表示坦克的 横坐标, y 表示纵坐标, direct 方向
function Hero(x,y,direct,color){
//下面两句话的作用是通过对象冒充，达到继承的效果
this.tank=T
this.tank(x,y,direct,color);
//增加一个函数，射击敌人坦克.
this.shotEnemy=function(){
//创建子弹, 子弹的位置应该和hero有关系，并且和hero的方向有关.!!!
//this.x 就是当前hero的横坐标,这里我们简单的处理(细化)
switch(this.direct){
heroBullet=new Bullet(this.x+9,this.y,this.direct,1);
heroBullet=new Bullet(this.x+30,this.y+9,this.direct,1);
heroBullet=new Bullet(this.x+9,this.y+30,this.direct,1);
case 3: //右
heroBullet=new Bullet(this.x,this.y+9,this.direct,1);
//调用我们的子弹run, 50 是老师多次测试得到的一个结论.
var timer=window.setInterval("heroBullet.run()",50);
//把这个timer赋给这个子弹(js对象是引用传递!)
heroBullet.timer=
//定义一个EnemyTank类
function EnemyTank (x,y,direct,color){
//也通过对象冒充，来继承Tank
this.tank=T
this.tank(x,y,direct,color);
//画出自己的子弹,多说一句，你也可以把该函数封装到Hero类中
function drawHeroBullet(){
//这里，我们加入了一句话，但是要知道这里加，是需要对整个程序有把握
if(heroBullet!=null&&heroBullet.isLive){
cxt.fillStyle="#FEF26E";
cxt.fillRect(heroBullet.x,heroBullet.y,2,2);
//绘制坦克
function drawTank(tank){
//考虑方向
switch(tank.direct){
case 0: //上
case 2:// 下
//画出自己的坦克，使用前面的绘图技术
//设置颜色
cxt.fillStyle=tank.color[0];
//韩老师使用 先死---&后活 (初学者最好用这个方法)
//先画出左面的矩形
cxt.fillRect(tank.x,tank.y,5,30);
//画出右边的矩形(这时请大家思路-&一定要一个参照点)
cxt.fillRect(tank.x+15,tank.y,5,30);
//画出中间矩形
cxt.fillRect(tank.x+6,tank.y+5,8,20);
//画出坦克的盖子
cxt.fillStyle=tank.color[1];
cxt.arc(tank.x+10,tank.y+15,4,0,360,true);
cxt.fill();
//画出炮筒(直线)
cxt.strokeStyle=tank.color[1];
//设置线条的宽度
cxt.lineWidth=1.5;
cxt.beginPath();
cxt.moveTo(tank.x+10,tank.y+15);
if(tank.direct==0){
cxt.lineTo(tank.x+10,tank.y);
}else if(tank.direct==2){
cxt.lineTo(tank.x+10,tank.y+30);
cxt.closePath();
cxt.stroke();
case 1: //右和左
//画出自己的坦克，使用前面的绘图技术
//设置颜色
cxt.fillStyle=tank.color[0];
//韩老师使用 先死---&后活 (初学者最好用这个方法)
//先画出左面的矩形
cxt.fillRect(tank.x,tank.y,30,5);
//画出右边的矩形(这时请大家思路-&一定要一个参照点)
cxt.fillRect(tank.x,tank.y+15,30,5);
//画出中间矩形
cxt.fillRect(tank.x+5,tank.y+6,20,8);
//画出坦克的盖子
cxt.fillStyle=tank.color[1];
cxt.arc(tank.x+15,tank.y+10,4,0,360,true);
cxt.fill();
//画出炮筒(直线)
cxt.strokeStyle=tank.color[1];
//设置线条的宽度
cxt.lineWidth=1.5;
cxt.beginPath();
cxt.moveTo(tank.x+15,tank.y+10);
if(tank.direct==1){
cxt.lineTo(tank.x+30,tank.y+10);
}else if(tank.direct==3){ //向左
cxt.lineTo(tank.x,tank.y+10);
cxt.closePath();
cxt.stroke();
&pre&&/pre&
更多信息请查看
更多信息请查看
易贤网手机网站地址：
【】&&&&&【点此处查询各地各类考试咨询QQ号码及交流群】
由于各方面情况的不断调整与变化，易贤网所提供的所有考试信息和咨询回复仅供参考，敬请考生以权威部门公布的正式信息和咨询为准！
云南各地招聘
&nbsp&nbsp&nbsp &nbsp&nbsp&nbsp会员注册
本站不参与评论，（&&点此深度交流 ）
自觉遵守：爱国、守法、自律、真实、文明的原则
尊重网上道德，遵守中华人民共和国各项有关法律法规
严禁发表危害国家安全，破坏民族团结、国家宗教政策和社会稳定，含侮辱、诽谤、教唆、淫秽等内容的评论
承担一切因您的行为而直接或间接导致的民事或刑事法律责任
您在本站发表的评论，本站有权保留、转载、引用或者删除
参与本评论即表明您已经阅读并接受上述条款Java坦克大战 (五) 之产生敌方坦克和爆炸效果
Java坦克大战 (五) 之产生敌方坦克和爆炸效果
[摘要：本文去自：小易专客专栏。转载请说明出处： http://blog.csdn.net/oldinaction 正在此小易将坦克大战那个项目分为几个版本，以此对J2SE的学问举行回想战总结，愿望如许也能给刚教完J2SE的小伙]
本文来自：小易博客专栏。转载请注明出处：http://blog.csdn.net/oldinaction
在此小易将坦克大战这个项目分为几个版本，以此对J2SE的知识进行回顾和总结，希望这样也能给刚学完J2SE的小伙伴们一点启示！
(此版本基本上就可以和电脑对打了，不信把源码放到你的电脑上就可以马上开启坦克大战之旅哦)
坦克大战V0.5实现功能：
1、产生一个敌方坦克
2、将敌人坦克击毙，相应的子弹和坦克都消失
3、添加爆炸效果
4、添加多辆坦克，并能够打掉敌方坦克
5、让敌方坦克可以随机运动，可以打出子弹打掉我方坦克
6、加两堵墙出来，可以吞没子弹，挡住敌方坦克
7、敌方坦克相撞不能穿透过去
注意事项：
1、画一辆敌人的坦克，步骤：加入区别敌我的量good，根据敌我的不同设置不同的颜色更新Tank的构造函数，加入good，TankClient中new 出敌人的坦克并画出(注意如果新增加了成员变量，就要马上考虑是否要更改或新增构造方法)
2、将敌人坦克击毙，分析：一颗子弹击中敌人坦克，步骤：Missle中加入hitTank(Tank)方法，返回布尔类型；利用碰撞检测的辅助类Rectangle；为Tank和Missle都加入getRect方法；当击中敌人坦克时，坦克被打死，子弹也死去；增加控制Tank生死的量live，如果死去就不画了
3、加入爆炸，步骤：添加爆炸类；用不同直径的圆模拟爆炸；加入live；加入位置属性；加入draw方法。爆炸应该存在于集合类中；TankClient加入集合；将集合中的爆炸逐一画出（如果死去就去除）。击毙一辆坦克后应产生爆炸；hitTank时应产生爆炸
4、添加多辆坦克，步骤：用容器来装敌人的Tank；向容器中装入多辆敌人Tank；画出来；运行，不能打掉；添加hitTanks方法，打一系列Tank；TankClient里面每发子弹都打tanks
5、让敌军坦克更加智能，步骤：
==&让敌军坦克动起来：构造函数中可以指定方向；new敌军坦克的时候指定敌军坦克的方向。
==&让敌军坦克向随机方向移动：(Tank)静态的，添加随机数产生器 java.util.Random；move完成后，如果是敌军坦克的，随机产生一个数，来设定坦克下一个方向；Direction.values()。
==&让敌军坦克向随机方向移动随机的步骤：添加变量，记录随机步骤；当==0时，改变方向，否则，只是随机步骤递减；
==&让敌军坦克发射炮弹：本军炮弹不打本军；炮弹添加好坏bGood，根据好坏画不同颜色；修改炮弹的构造方法；修改Tank的fire方法；修改hitTank方法，好不能打好，坏不能打坏
6、添加两堵墙，步骤：建Wall类、建立Wall对象、画出来。
==&让每一颗子弹打击每一堵墙：hitWall()方法；注意子弹速度不能太快，否则很容易穿过墙；
==&让坦克不能穿过墙：记录上一次的位置oldX, oldY；修改构造函数；每次move之前纪录上一次位置；添加stay方法；记录移动前的位置；当撞到时回到移动前的位置；当碰到墙的时候stay
坦克大战V0.5源代码：
TankClient类：
import java.awt.*; import java.awt.event.*; import java.util.L //java.awt包中也有个List，所以此处要导包明确 import java.util.ArrayL
public class TankClient extends Frame {
public static final int GAME_WIDTH = 800;
public static final int GAME_HEIGHT = 600;
Tank myTank = new Tank(350, 450, true, Tank.Direction.STOP, this); //我方坦克
Wall w1 = new Wall(100, 300, 20, 100, this), w2 = new Wall(300, 250, 150, 20, this);
List&Missile& missiles = new ArrayList&Missile&(); //定义一个集合来装子弹
List&Explode& explodes = new ArrayList&Explode&();
List&Tank& tanks = new ArrayList&Tank&();
Image offScreenImage = //定义一个屏幕后的虚拟图片
public void paint(Graphics g) {
g.drawString(&missiles Count: & + missiles.size(), 10, 50); //用来记录missiles中子弹的个数
g.drawString(&explodes Count: & + explodes.size(), 10, 70);
g.drawString(&tanks Count: & + tanks.size(), 10, 90);
for (int i = 0; i & missiles.size(); i++) { //遍历集合，把其中的子弹画出来
Missile m = missiles.get(i);
m.hitTanks(tanks);
m.hitTank(myTank);
m.hitWall(w1); //检测子弹是否撞墙
m.hitWall(w2);
m.drawMissile(g);
for (int i = 0; i & explodes.size(); i++) {
Explode e = explodes.get(i);
e.draw(g);
for (int i = 0; i & tanks.size(); i++) {
Tank t = tanks.get(i);
t.collidesWithWall(w1); //检测敌方坦克是否撞墙
t.collidesWithWall(w2);
t.collidesWithTanks(tanks);
t.drawTank(g);
myTank.drawTank(g);
w1.draw(g);
w2.draw(g);
//利用双缓冲消除圆圈移动时屏幕的闪动
public void update(Graphics g) {
if (offScreenImage == null) {
offScreenImage = this.createImage(GAME_WIDTH, GAME_HEIGHT); //判断是为了避免每次重画时都给offScreenImage赋值
Graphics gOffScreen = offScreenImage.getGraphics(); //定义虚拟图片上的画笔gOffScreen
Color c = gOffScreen.getColor();
gOffScreen.setColor(Color.GREEN);
gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HEIGHT); //重画背景，如果没有这句则在屏幕上会保留圆圈的移动路径
gOffScreen.setColor(c);
paint(gOffScreen); //把圆圈画到虚拟图片上
g.drawImage(offScreenImage, 0, 0, null); //再一次性把虚拟图片画到真实屏幕上，在真实屏幕上画则要用真实屏幕的画笔g
public void luanchFrame() {
for(int i = 0; i & 10; i++) {
tanks.add(new Tank(50 + 40*(i+1), 50, false,Tank.Direction.D, this));
this.setLocation(300, 50);
this.setSize(GAME_WIDTH, GAME_HEIGHT);
this.setTitle(&坦克大战 - By:小易 - QQ：&);
this.setResizable(false); //不允许改变窗口大小
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}); //添加关闭功能，此处使用匿名类比较合适
this.setBackground(Color.GREEN);
this.addKeyListener(new KeyMonitor());
setVisible(true);
new Thread(new PaintThread()).start(); //启动线程，实例化线程对象时不要忘了new Thread(Runnable对象);
public static void main(String[] args) {
TankClient tc = new TankClient();
tc.luanchFrame();
//PaintThread只为TankClient服务，所以写成内部类好些
public class PaintThread implements Runnable {
public void run() {
while (true) {
repaint(); //repaint()是TankClient或者他的父类的方法，内部类可以访问外部包装类的成员，这也是内部类的好处
Thread.sleep(50); //每隔50毫秒重画一次
} catch (InterruptedException e) {
e.printStackTrace();
public class KeyMonitor extends KeyAdapter {
public void keyReleased(KeyEvent e) {
myTank.keyReleased(e);
public void keyPressed(KeyEvent e) {
myTank.keyPressed(e);
import java.awt.*; import java.awt.event.*; import java.util.R
public class Tank {
public static final int XSPEED = 5; //定义常量X轴速度
public static final int YSPEED = 5;
public static final int WIDTH = 30;
public static final int HEIGHT = 30;
//定义一个随机数产生器，此时的Random类是java.util.Random，不同于Math中的
private static Random r = new Random(); //随机数产生器只需要一个，所以定义成静态，防止每次new一个坦克是都会产生一个随机数产生器
//定义变量说明是我方还是敌方坦克，为true表示我方坦克
private boolean live = //定义变量说明是坦克是否存活
private int x , //定义变量画圆圈(坦克)时四边形左上点的x、y左边
private int oldX , oldY; //定义坦克上个位置的坐标
private boolean bL = false, bU = false, bR = false, bD = //定义变量左上右下的按键是否被按下
enum Direction {L,LU,U,RU,R,RD,D,LD,STOP}; //定义枚举类型，值为左、左上、上、右上、右、右下、下、左下、停止
private Direction dir = Direction.STOP; //定义变量坦克的方向
private Direction ptDir = Direction.D; //定义变量坦克炮筒的方向，起初向下
private int step = r.nextInt(12) + 3; //定义坦克朝着一个方向移动几步
public Tank(int x, int y, boolean good) {
this.good =
this.oldX =
this.oldY =y;
public Tank(int x, int y, boolean good, Direction dir, TankClient tc) {
this(x, y, good); //相当于调用上面的构造方法
this.dir =
public void drawTank(Graphics g) {
if(!live) {
if(!good) {
tc.tanks.remove(this);
//如果坦克没有存活就直接返回，不用画坦克了
Color c = g.getColor(); //取得g(以后称为画笔)的颜色
if(good) g.setColor(Color.RED);
else g.setColor(Color.BLUE);
g.fillOval(x, y, WIDTH, HEIGHT); //&画圆&,利用填充一个四边形(四边形的内切圆)，参数分别代表：四边形左上点的坐标X，Y，宽度，高度
g.setColor(c); //用完画笔后把画笔默认的颜色(黑色)设置回去
//根据炮筒的方向，画直线代表炮筒
switch (ptDir) {
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y+Tank.HEIGHT/2);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH/2, y);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y+Tank.HEIGHT/2);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH, y+Tank.HEIGHT);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x+Tank.WIDTH/2, y+Tank.HEIGHT);
g.drawLine(x+Tank.WIDTH/2, y+Tank.HEIGHT/2, x, y+Tank.HEIGHT);
move(); //每次按键都会重画，就会调用drawTank，在这里重画坦克的此时位置
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode(); //得到按键的虚拟码，再和下面的KeyEvent.VK_LEFT等虚拟码比较看是否是某按键
switch (key) {
case KeyEvent.VK_LEFT:
case KeyEvent.VK_UP:
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_DOWN:
locateDraction();
if (dir != Direction.STOP) {
public void keyReleased(KeyEvent e) {
int key = e.getKeyCode();
switch (key) {
case KeyEvent.VK_R: //按R就发射子弹调用fire方法
fire(); //只有松开R才能发出子弹
case KeyEvent.VK_LEFT:
case KeyEvent.VK_UP:
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_DOWN:
locateDraction();
//通过上右下的按键是否被按下判断坦克要运动的方向
void locateDraction() {
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 move() {
switch (dir) {
x -= XSPEED;
x -= XSPEED;
y -= YSPEED;
y -= YSPEED;
x += XSPEED;
y -= YSPEED;
x += XSPEED;
x += XSPEED;
y += YSPEED;
y += YSPEED;
x -= XSPEED;
y += YSPEED;
case STOP:
if(this.dir != Direction.STOP) {
this.ptDir = this.
//防止坦克出界
if (x & 0) x = 0;
if (y & 25) y = 25; //考虑了标题栏的高度
if (x + Tank.WIDTH & TankClient.GAME_WIDTH) x = TankClient.GAME_WIDTH - Tank.WIDTH;
if (y + Tank.HEIGHT & TankClient.GAME_HEIGHT) y = TankClient.GAME_HEIGHT - Tank.HEIGHT;
if (!good) {
Direction[] dirs = Direction.values(); //把枚举转换成数组
if (step == 0) {
int rn = r.nextInt(dirs.length);
dir = dirs[rn]; //如果移动步数为0就改变方向
step = r.nextInt(12) + 3;
if(r.nextInt(40) & 37) this.fire();
public void stay() {
//坦克开火，就new一个子弹出来
private Missile fire() {
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); //每new一个Missile对象就把他装到集合中
//返回的m，其他地方可调用可不调用
public Rectangle getRect() {
return new Rectangle(x, y, WIDTH, HEIGHT); //得到坦克的探测方块，Rectangle是java.awt包中专门用于游戏碰撞的类
public boolean isLive() {
//Tank类的成员方法可生成对应的get和set方法，那么在其他类中就可以访问了
public void setLive(boolean live) {
this.live =
public boolean isGood() {
//检测坦克是否撞墙
public boolean collidesWithWall(Wall w) {
if(this.live && this.getRect().intersects(w.getRect())) {
stay(); //如果坦克撞到墙就让他回到上一个位置
//检测坦克是否相撞,java.util.List&E&接口或者类的另一种写法，java.awt中也有List，所以要写明确
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();
Missile类：
import java.awt.*; import java.util.L
public class Missile {
public static final int XSPEED = 10;
public static final int YSPEED = 10;
public static final int WIDTH = 10;
public static final int HEIGHT = 10;
//定义变量表示是否是我方子弹
private boolean live = //定义一个判断子弹是否出界的变量
private TankC
public Missile(int x, int y, Tank.Direction dir) {
this.dir =
public Missile(int x, int y,boolean good, Tank.Direction dir, TankClient tc) {
this(x, y, dir);
this.good =
public void drawMissile(Graphics g) {
if(!live) {
tc.missiles.remove(this);
Color c = g.getColor();
g.setColor(Color.BLACK);
g.fillOval(x, y, WIDTH, HEIGHT);
g.setColor(c);
private void move() {
switch (dir) {
x -= XSPEED;
x -= XSPEED;
y -= YSPEED;
y -= YSPEED;
x += XSPEED;
y -= YSPEED;
x += XSPEED;
x += XSPEED;
y += YSPEED;
y += YSPEED;
x -= XSPEED;
y += YSPEED;
if (x & 0 || y & 0 || x & tc.GAME_WIDTH || y & tc.GAME_HEIGHT) {
public boolean isLive() {
public Rectangle getRect() {
return new Rectangle(x, y, WIDTH, HEIGHT); //得到子弹的探测方块，Rectangle是java.awt包中专门用于游戏碰撞的类
//判断子弹是否打到了坦克
public boolean hitTank(Tank t) {
//intersects是Rectangle的一个方法；t.isLive()是为了判断坦克是否存活，如果没有则打掉这个坦克后，之后的子弹到达原来这个坦克的位置就会消失
if (this.live && this.getRect().intersects(t.getRect()) && t.isLive() && this.good != t.isGood()) {
t.setLive(false);
this.live =
Explode e = new Explode(x, y, tc);
tc.explodes.add(e);
public boolean hitTanks(List&Tank& tanks) {
for (int i = 0; i & tanks.size(); i++) {
if (hitTank(tanks.get(i))) {
public boolean hitWall(Wall w) {
if(this.live && this.getRect().intersects(w.getRect())) {
this.live =
Explode类：
import java.awt.*;
//爆炸类(爆炸的英文：explode) public class Explode {
private TankC
private boolean live =
int[] diameter = {4, 10, 20, 36, 56, 24, 12, 6}; //定义画不同直径的圆表示爆炸(直径的英文:diameter)
int step = 0; //定义变量代表画爆炸的圆画到第几个了
public Explode(int x, int y, TankClient tc) {
public void draw(Graphics g) {
if(!live) {
tc.explodes.remove(this);
if (step == diameter.length) {
Color c = g.getColor();
g.setColor(Color.ORANGE);
g.fillOval(x, y, diameter[step], diameter[step]);
g.setColor(c);
import java.awt.*;
public class Wall {
private int x, y, w,
private TankC
public Wall(int x, int y, int w, int h, TankClient tc) {
public void draw(Graphics g) {
g.fillRect(x, y, w, h);
public Rectangle getRect() {
return new Rectangle(x, y, w, h);
知识点回顾：
1、碰撞检测的辅助类Rectangle，属于java.awt.Rectangle中,用法：
==&首先获取两个要检测物体的边界，相当于一个Rectangle对象，可以给他们定义相应的getRect()方法，返回值为一个Rectangle对象，在函数内return
new Rectangle(x, y, w, h);
==&定义一个方法判断是否碰撞到了，返回值为boolean，物体1.getRect().intersects(物体2.getRect())的返回值也是一个boolean类型，返回真则表示碰撞到了，再执行相应的功能，反之亦然。
2、将枚举转换成数组：枚举名.values()，返回的是相应的数组。如：Direction[] dirs = Direction.values();返回的是Direction类型的数组
3、随机数的使用：
==&java.util.Random比较方便，可以直接产生随机整数，使用时先定义一个随机数产生器，如：定义随机数产生器：Random
r = new Random(); 产生随机数整数：r.nextInt(12)表示产生一个0-11的随机整数
==&math.random()产生的是一个0-1的数，使用时一般要通过计算转换，比较麻烦
感谢关注 Ithao123精品文库频道，是专门为互联网人打造的学习交流平台，全面满足互联网人工作与学习需求，更多互联网资讯尽在 IThao123!
Laravel是一套简洁、优雅的PHP Web开发框架(PHP Web Framework)。它可以让你从面条一样杂乱的代码中解脱出来；它可以帮你构建一个完美的网络APP，而且每行代码都可以简洁、富于表达力。
Hadoop是一个由Apache基金会所开发的分布式系统基础架构。
用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。
Hadoop实现了一个分布式文件系统（Hadoop Distributed File System），简称HDFS。HDFS有高容错性的特点，并且设计用来部署在低廉的（low-cost）硬件上；而且它提供高吞吐量（high throughput）来访问应用程序的数据，适合那些有着超大数据集（large data set）的应用程序。HDFS放宽了（relax）POSIX的要求，可以以流的形式访问（streaming access）文件系统中的数据。
Hadoop的框架最核心的设计就是：HDFS和MapReduce。HDFS为海量的数据提供了存储，则MapReduce为海量的数据提供了计算。
产品设计是互联网产品经理的核心能力，一个好的产品经理一定在产品设计方面有扎实的功底，本专题将从互联网产品设计的几个方面谈谈产品设计
随着国内互联网的发展，产品经理岗位需求大幅增加，在国内，从事产品工作的大部分岗位为产品经理，其实现实中，很多从事产品工作的岗位是不能称为产品经理，主要原因是对产品经理的职责不明确，那产品经理的职责有哪些，本专题将详细介绍产品经理的主要职责
IThao123周刊