大学课程设计飞机大战.docx

大学课程设计飞机大战.docx

《大学课程设计飞机大战.docx》由会员分享，可在线阅读，更多相关《大学课程设计飞机大战.docx（30页珍藏版）》请在冰豆网上搜索。

大学课程设计飞机大战

湖北大学本科课程设计

题目Java课程设计——飞机大战

姓名学号

专业年级

指导教师职称

2015年12月18日

----目录----

1．项目介绍--------------------------------1

2．概要设计

2.1资源需求------------------------------1

2.2游戏流程------------------------------1

3．类设计

3.1游戏界面类----------------------------2

3.2飞行物类------------------------------2

3.3敌机类--------------------------------2

3.4蜜蜂类--------------------------------3

3.5玩家飞机类-----------------------------3

3.6子弹类--------------------------------4

4．编码分析

4.1游戏界面类----------------------------4

4.2飞行物类------------------------------11

4.3敌机类--------------------------------12

4.4蜜蜂类--------------------------------13

4.5玩家飞机类-----------------------------13

4.6子弹类--------------------------------15

5．游戏测试画面-----------------------------16

6．总结------------------------------------18

一．项目介绍

针对Java课程设计，我做了一个小游戏——飞机大战，游戏代码包含到本学期所学的所有知识点。

程序运行后，进入到开始画面，鼠标单击开始游戏。

敌机自上向下移动，随机出现，玩家机随鼠标移动并发射子弹，消灭敌机可以获得分数，随机出现小蜜蜂，消灭后可获得奖励。

二．概要设计

2.1资源需求

此游戏需要导入图片：

背景图片，开始界面，玩家飞机，敌机，小蜜蜂，子弹，暂停界面，结束界面。

2.2游戏流程

单击鼠标

鼠标移出

单击鼠标

玩家死亡

三．程序结构

游戏界面：

ShootGameextendsJPanel

static块：

导入图片

main（）：

创建窗口

重写paint（）：

画图

action（）：

鼠标事件

TimerTask重写run（）：

游戏运行的活动

飞行物类：

abstractFlyingObject

属性:

x,y坐标，image，图片长宽

move（）:

飞行物移动

outOfbound（）:

飞行物出界

shootBy（）:

子弹击中飞行物

敌机类：

AirplaneextendsFlyingObject

Intspeed：

移动速度

重写move（）

重写outOfBound（）

getScore（）：

击中敌机后得分

Airplane（）：

初始化敌机

蜜蜂类：

BeeextendsFlyingObject

IntxSpeed，ySpeed：

移动速度

IntawardType:

奖励类型（双倍活力或加命）

Bee（）：

初始化蜜蜂

重写move（）

重写outOfBound（）

getType（）：

获取奖励类型

玩家飞机类：

PlayerextendsFlyingObject

Intlife，doubleFire：

生命，双倍火力

Player（）：

初始化玩家

重写move（）：

换图片，形成飞机的动态效果

重写outOfBound（）

shoot（）：

生成子弹

moveTo（）：

玩家机移动

isHit（）：

玩家碰撞到飞行物

setDoubleFire（）：

设置双倍火力

addDoubleFire（）：

奖励双倍火力

addLife（）：

奖励生命

deleteLife（）：

减命

getLife（）：

获取生命数

子弹类：

BulletextendsFlyingObject

Intspeed：

移动速度

Bullet（）：

初始化子弹

重写move（）

重写outOfBound（）

四．编码分析

（1）ShootGame类

此类继承JPanel类构建游戏窗口并控制游戏的运行

类的成员变量：

publicstaticfinalintWIDTH=400;//窗口宽

publicstaticfinalintHEIGHT=600;//窗口高

//图片属性

publicstaticBufferedImageairplane;

publicstaticBufferedImagebackground;

publicstaticBufferedImagebee;

publicstaticBufferedImagebullet;

publicstaticBufferedImagegameover;

publicstaticBufferedImageplayer0;

publicstaticBufferedImageplayer1;

publicstaticBufferedImagepause;

publicstaticBufferedImagestart;

publicstaticfinalintDOUBLE_FIRE=0;//双倍火力的属性为0

publicstaticfinalintLIFE=1;//奖励生命的属性为1

publicPlayerplayer=newPlayer（）;//创建玩家对象

privateBullet[]bullets={};//创建子弹对象（当前为空）

privateFlyingObject[]flyings={};//创建飞行物对象（当前为空）

publicstaticfinalintSTART=0;//状态:

开始为0

publicstaticfinalintRUNNING=1;//状态：

运行为1

publicstaticfinalintPAUSE=2;//状态：

暂停为2

publicstaticfinalintGAME_OVER=3;//状态：

游戏结束为3

privateintstate=0;//当前状态

1.static块

静态块，在类加载时导入游戏所需的图片

static{

try{

airplane=ImageIO.read（ShootGame.class.getResource（"airplane.png"））;

background=ImageIO.read（ShootGame.class.getResource（"background.png"））;

bee=ImageIO.read（ShootGame.class.getResource（"bee.png"））;

bullet=ImageIO.read（ShootGame.class.getResource（"bullet.png"））;

gameover=ImageIO.read（ShootGame.class.getResource（"gameover.png"））;

pause=ImageIO.read（ShootGame.class.getResource（"pause.png"））;

start=ImageIO.read（ShootGame.class.getResource（"start.png"））;

player0=ImageIO.read（ShootGame.class.getResource（"player0.png"））;

player1=ImageIO.read（ShootGame.class.getResource（"player1.png"））;

}catch（Exceptione）{

e.printStackTrace（）;

}

}

2.main（）

在main方法中创建窗口

publicstaticvoidmain（String[]args）{

JFrameframe=newJFrame（"ShootGame"）;

ShootGamegame=newShootGame（）;

frame.add（game）;

frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）;

frame.setLocation（400,100）;

frame.setAlwaysOnTop（true）;

frame.setVisible（true）;

frame.setSize（WIDTH,HEIGHT）;

game.action（）;

}

3.paint（）

//画图（g是画笔）

publicvoidpaint（Graphicsg）{

g.drawImage（background,0,0,null）;

paintPlayer（g）;//画玩家飞机

paintFlyings（g）;//画飞行物

paintBullets（g）;//画子弹

paintScore（g）;//画分数

paintState（g）;//画游戏状态

}

//画每一个子弹

privatevoidpaintBullets（Graphicsg）{

for（inti=0;i

Bulletb=bullets[i];

g.drawImage（b.image,b.x,b.y,null）;

}

}

//画飞行物（敌机，蜜蜂）

privatevoidpaintFlyings（Graphicsg）{

for（inti=0;i

FlyingObjectflying=flyings[i];

g.drawImage（flying.image,flying.x,flying.y,null）;

}

}

//画玩家

privatevoidpaintPlayer（Graphicsg）{

g.drawImage（player.image,player.x,player.y,null）;

}

//画分数

publicvoidpaintScore（Graphicsg）{

g.setColor（Color.RED）;//设置画笔颜色为红

g.setFont（newFont（Font.SANS_SERIF,Font.BOLD,20））;//设置字体，加粗，字号

g.drawString（"Score:

"+score,10,25）;

g.drawString（"Life:

"+player.getLife（）,10,45）;

}

//画状态

publicvoidpaintState（Graphicsg）{

switch（state）{

caseSTART:

g.drawImage（start,0,0,null）;break;

casePAUSE:

g.drawImage（pause,0,0,null）;break;

caseGAME_OVER:

g.drawImage（gameover,0,0,null）;break;

}

}

4.action（）

此方法处理鼠标响应事件：

玩家机随鼠标移动，点击鼠标则游戏开始，鼠标移出则暂停游戏

publicvoidaction（）{

MouseAdapterl=newMouseAdapter（）{

//鼠标移动事件

publicvoidmouseMoved（MouseEvente）{

if（state==RUNNING）{

intx=e.getX（）;

inty=e.getY（）;

player.moveTo（x,y）;

}

}

//鼠标点击事件：

如果当前状态为start则开始游戏，如果当前状态为游戏结束则初始化所有对象，游戏重新开始

publicvoidmouseClicked（MouseEvente）{

switch（state）{

caseSTART:

state=RUNNING;

break;

caseGAME_OVER:

flyings=newFlyingObject[0];

player=newPlayer（）;

bullets=newBullet[0];

score=0;

state=START;

}

}

//鼠标移出，在当前状态为运行的情况下，改state为暂停

publicvoidmouseExited（MouseEvente）{

if（state==RUNNING）{

state=PAUSE;

}

}

//鼠标移入，在当前状态为暂停的情况下，游戏继续运行

publicvoidmouseEntered（MouseEvente）{

if（state==PAUSE）{

state=RUNNING;

}

}

};

this.addMouseListener（l）;

this.addMouseMotionListener（l）;

5.TimerTask.run（）//游戏运行

privateTimertimer;

privateintinterval=10;//时间间隔，10毫秒

intscore=0;//分数

timer=newTimer（）;

//每隔10毫秒运行一次run方法

timer.schedule（newTimerTask（）{

@Override

publicvoidrun（）{

if（state==RUNNING）{

enterAction（）;//飞行物入场（敌机或蜜蜂）

stepAction（）;//飞行物移动

shootAction（）;//射击（子弹入场）

bangAction（）;//碰撞

outOfBoundsAction（）;//删除出界对象

checkGameOverAction（）;//检查游戏结束

}

repaint（）;

}

},interval,interval）;

}

//子弹击中飞行物

publicvoidbangAction（）{

for（inti=0;i

if（bang（bullets[i]））{

Bulletb=bullets[i];

bullets[i]=bullets[bullets.length-1];

bullets[bullets.length-1]=b;

bullets=Arrays.copyOf（bullets,bullets.length-1）;

}

}

}

//判断每一个子弹和飞行物是否碰撞

publicbooleanbang（Bulletb）{

intindex=-1;//被击中的飞行物下标

for（inti=0;i

FlyingObjectobj=flyings[i];

if（obj.shootBy（b））{

index=i;

break;

}

}

if（index!

=-1）{

FlyingObjectobj=flyings[index];

//判断被击中的飞行物是什么类型，是敌机则得分，是蜜蜂则获得奖励

if（objinstanceofAirplane）{

Airplanea=（Airplane）obj;

score+=a.getScore（）;

}

if（objinstanceofBee）{

Beebee=（Bee）obj;

inttype=bee.getType（）;

switch（type）{

caseDOUBLE_FIRE:

player.addDoubleFile（）;break;

caseLIFE:

player.addLife（）;break;

}

}

flyings[index]=flyings[flyings.length-1];

flyings[flyings.length-1]=obj;//将击中的飞行物放到最后,并删去

flyings=Arrays.copyOf（flyings,flyings.length-1）;

returntrue;

}else{

returnfalse;

}

}

//删除出界飞行物

publicvoidoutOfBoundsAction（）{

FlyingObject[]flyingAlive=newFlyingObject[flyings.length];

intindex=0;//新数组的下标

//将未出界的飞行物放入新的数组

for（inti=0;i

if（!

flyings[i].outOfBound（））{

flyingAlive[index]=flyings[i];

index++;

}

}

flyings=Arrays.copyOf（flyingAlive,index）;//缩小数组，将出界的飞机删除

index=0;

Bullet[]bulletAlive=newBullet[bullets.length];

//将未出界的子弹放入新的数组

for（inti=0;i

if（!

bullets[i].outOfBound（））{

bulletAlive[index]=bullets[i];

index++;

}

}

bullets=Arrays.copyOf（bulletAlive,index）;//缩小数组，将出界的子弹删除

}

//检查游戏是否结束

publicvoidcheckGameOverAction（）{

if（isGameOver（））{

state=GAME_OVER;

}

//判断游戏结束

publicbooleanisGameOver（）{

for（inti=0;i

intindex=-1;//被撞的飞行物下标

if（player.isHit（flyings[i]））{

player.deleteLife（）;

player.setDoubleFire（0）;

index=i;

}

if（index!

=-1）{//将被撞的飞行物从数组中删除

FlyingObjectobj=flyings[index];

flyings[index]=flyings[flyings.length-1];

flyings[flyings.length-1]=obj;

flyings=Arrays.copyOf（flyings,flyings.length-1）;

}

}

returnplayer.getLife（）<=0;

}

intshootIndex=0;//射击频率

//玩家发射子弹（生成子弹）

publicvoidshootAction（）{

shootIndex++;//300毫秒新建一组子弹

if（shootIndex%30==0）{

Bullet[]bs=player.shoot（）;

//将新建的子弹加入到子弹数组中

bullets=Arrays.copyOf（bullets,bs.length+bullets.length）;

System.arraycopy（bs,0,bullets,bullets.length-bs.length,bs.length）;

}

}

//子弹，玩家，飞行物走步

publicvoidstepAction（）{

for（inti=0;i

flyings[i].move（）;

}

for（inti=0;i

bullets[i].move（）;

}

player.move（）;

}

intflyEnteredIndex=0;//飞行物入场计数

//飞行物入场（新建对象）

publicvoidenterAction（）{

flyEnteredIndex++;//400毫秒新建一个飞行物（敌机或蜜蜂）

if（flyEnteredIndex%40==0）{

FlyingObjectobj=nextOne（）;

flyings=Arrays.copyOf（flyings,flyings.length+1）;//扩容

flyings[flyings.length-1]=obj;

}

}

//工厂方法：

生成对象

publicstaticFlyingObjectnextOne（）{

Randomrand=newRandom（）;

inttype=rand.nextInt（20）;

//生成蜜蜂的概率为5%

if（type==0）{

returnnewBee（）;

}else{

returnnewAirplane（）;

}

}

（2）FlyingObject类

成员变量：

protectedintx;//x坐标

protectedinty;//y坐标

pro