JME手机游戏设计方案案例源代码SpaceWarEnemy.docx

JME手机游戏设计方案案例源代码SpaceWarEnemy.docx

《JME手机游戏设计方案案例源代码SpaceWarEnemy.docx》由会员分享，可在线阅读，更多相关《JME手机游戏设计方案案例源代码SpaceWarEnemy.docx（90页珍藏版）》请在冰豆网上搜索。

JME手机游戏设计方案案例源代码SpaceWarEnemy

*********GameMID

/*@authorwizardyx*/

importjavax.microedition.lcdui.Display。

importjavax.microedition.midlet.*。

/*游戏MIDlet*/

publicclassGameMIDextendsMIDlet{

privateDisplaydisplay。

//声明Display

privateStartScreenstartscreen。

//声明启动画面对象

privateFlashScreenflashscreen。

//声明闪屏画面对象

privateGameMenugmenu。

//声明菜单画面对象

privateGameWorldgw。

//声明游戏引擎框架

privateGameMusicgm。

//声明音效对象

publicGameMID（）{

display=Display.getDisplay（this）。

//获取Display

gm=newGameMusic（）。

loadFlashScreen（）。

//加载闪屏画面

}

publicvoidstartApp（）{

}

publicvoidpauseApp（）{

}

publicvoiddestroyApp（booleanunconditional）{

gmenu=null。

flashscreen=null。

startscreen=null。

gm=null。

GameMusic.releases（）。

System.gc（）。

//释放资源

}

/*退出程序*/

publicvoidexit（）{

try{

destroyApp（false）。

}catch（Exceptione）{}

notifyDestroyed（）。

}

/*加载游戏启动画面*/

publicvoidloadStartScreen（）{

flashscreen=null。

startscreen=null。

startscreen=newStartScreen（this）。

//创建启动画面

display.setCurrent（startscreen）。

//设置启动画面为当前显示画面

}

/*加载闪屏画面*/

publicvoidloadFlashScreen（）{

flashscreen=newFlashScreen（this）。

//创建闪屏

display.setCurrent（flashscreen）。

//设置闪屏画面为当前显示画面

}

/*加载游戏菜单*/

publicvoidloadGameMenu（intmenuIndex）{

flashscreen=null。

startscreen=null。

if（gmenu==null）{

gmenu=newGameMenu（this）。

//创建菜单

}

gmenu.setMenuIndex（menuIndex）。

//设置当前菜单项

display.setCurrent（gmenu）。

//设置菜单画面为当前显示画面

}

/*加载游戏主界面*/

publicvoidloadGameWorld（）{

gmenu=null。

if（gw==null）{

gw=newGameWorld（this）。

//创建游戏引擎画布

}

display.setCurrent（gw）。

//设置游戏引擎画布为当前显示画面

gw.start（）。

}

}\

*********Bullet

/*@authorwizardyx*/

importjava.io.IOException。

importjava.util.Vector。

importjavax.microedition.lcdui.Graphics。

importjavax.microedition.lcdui.Image。

importjavax.microedition.lcdui.game.Sprite。

/*

*Tochangethistemplate,chooseTools|Templates

*andopenthetemplateintheeditor.

*/

/*玩家子弹类*/

publicclassBullet{

Planeplane。

//玩家飞机

Spritesprbullet。

//子弹精灵

Imageimgbullet。

//子弹图像

privateintbulletPower。

privateintbulletSpeed=4。

//子弹速度

privateintshootTimes。

//子弹发射计时

privateintbulletStay=15。

//子弹发射间隔时间

publicVectorv。

//子弹向量

publicBullet（Planeplane）{

try{

imgbullet=Image.createImage（"/mybullet.png"）。

//子弹图像

}catch（IOExceptionex）{

ex.printStackTrace（）。

}

sprbullet=newSprite（imgbullet,imgbullet.getWidth（）,imgbullet.getHeight（））。

//创建子弹精灵

sprbullet.defineReferencePixel（imgbullet.getWidth（）/2,imgbullet.getHeight（）/2）。

//设置参考点

this.plane=plane。

//引用玩家飞机

v=newVector（）。

//创建存储子弹数据的Vector

shootTimes=0。

//初始化子弹发射间隔时间

}

/*增加新子弹*/

publicvoidaddNew（）{

//初始化子弹坐标为飞机坐标

intp_x=plane.getX（）+plane.getWidth（）/2。

intp_y=plane.getY（）。

//根据子弹威力级别，添加不同的子弹

switch（bulletPower）{

case1:

{//前两个参数是子弹的当前坐标，第3个参数是子弹在水平方向上的速度

inta[]={p_x-5,p_y,0}。

//一级子弹数据

intb[]={p_x+5,p_y,0}。

v.addElement（a）。

//添加子弹数据到v中

v.addElement（b）。

}

break。

case2:

{

inta[]={p_x-8,p_y+5,0}。

//二级子弹数据

intb[]={p_x,p_y,0}。

intc[]={p_x+8,p_y+5,0}。

v.addElement（a）。

v.addElement（b）。

v.addElement（c）。

}

break。

case3:

{

inta[]={p_x-8,p_y+5,-1}。

//三级子弹数据

intb[]={p_x-5,p_y,0}。

intc[]={p_x+5,p_y,0}。

intd[]={p_x+8,p_y+5,1}。

v.addElement（a）。

v.addElement（b）。

v.addElement（c）。

v.addElement（d）。

}

break。

case4:

{

inta[]={p_x-8,p_y,0}。

//四级子弹数据

intb[]={p_x+8,p_y,0}。

intc[]={p_x,p_y,0}。

intd[]={p_x-10,p_y+8,-1}。

inte[]={p_x+10,p_y+8,1}。

intf[]={p_x-14,p_y+8,-1}。

intg[]={p_x+14,p_y+8,1}。

v.addElement（a）。

v.addElement（b）。

v.addElement（c）。

v.addElement（d）。

v.addElement（e）。

v.addElement（f）。

v.addElement（g）。

}

break。

case5:

{

inta[]={p_x-4,p_y,0}。

//五级子弹数据

intb[]={p_x,p_y,0}。

intc[]={p_x+4,p_y,0}。

intd[]={p_x-6,p_y+6,-1}。

inte[]={p_x+6,p_y+6,1}。

intf[]={p_x-10,p_y+8,-1}。

intg[]={p_x+10,p_y+8,1}。

inth[]={p_x-10,p_y+10,-2}。

inti[]={p_x+10,p_y+10,2}。

intj[]={p_x-14,p_y+12,-2}。

intk[]={p_x+14,p_y+12,2}。

v.addElement（a）。

v.addElement（b）。

v.addElement（c）。

v.addElement（d）。

v.addElement（e）。

v.addElement（f）。

v.addElement（g）。

v.addElement（h）。

v.addElement（i）。

v.addElement（j）。

v.addElement（k）。

}

break。

}

}

/*删除指定的子弹*/

publicvoiddelBullet（inti）{

if（i

v.removeElementAt（i）。

}

}

/*绘制子弹*/

publicvoidrender（Graphicsg）{

introw[]=null。

//循环绘制子弹

for（inti=0。

i

i++）{

row=（int[]）v.elementAt（i）。

//从v中获取子弹数据

sprbullet.setRefPixelPosition（row[0],row[1]）。

//设置子弹精灵的位置

sprbullet.paint（g）。

//绘制子弹

}

}

/*设置子弹威力级别*/

publicvoidsetBulletPower（intbulletPower）{

this.bulletPower=bulletPower。

}

/*获取子弹威力级别*/

publicintgetBulletPower（）{

returnbulletPower。

}

/*更新子弹数据*/

publicvoidupdate（）{

intbulletData[]=null。

//用于临时记录子弹数据

shootTimes++。

//子弹发射时间递增

//当玩家飞机生命值大于0时，每隔bulletStay次循环发射一次子弹

if（plane.getLifes（）>0&&shootTimes%bulletStay==0）{

addNew（）。

//增加子弹

shootTimes=0。

//重置子弹发射时间

}

for（inti=v.size（）-1。

i>=0。

i--）{

bulletData=（int[]）v.elementAt（i）。

//获取子弹数据

bulletData[0]=bulletData[0]+2*bulletData[2]。

//计算子弹X坐标

bulletData[1]-=bulletSpeed。

//按子弹速度计算Y坐标

//检查子弹是否超出屏幕

if（bulletData[1]<0||bulletData[0]<0||bulletData[0]>240）{

delBullet（i）。

//当子弹超出屏幕范围，删除子弹

}

else{

v.setElementAt（bulletData,i）。

//更新子弹数据

}

}

}

/*子弹碰撞检测*/

publicintcollidesWith（Spritespr）{

intn=0。

//初始化碰撞次数

intbulletData[]=null。

//初始化子弹数据数组

for（inti=v.size（）-1。

i>=0。

i--）{

bulletData=（int[]）v.elementAt（i）。

//获取子弹数据

sprbullet.setRefPixelPosition（bulletData[0],bulletData[1]）。

//设置子弹精灵位置

//当子弹发生碰撞，删除子弹，并记入碰撞次数

if（sprbullet.collidesWith（spr,false））{

delBullet（i）。

n++。

}

}

returnn。

//返回碰撞次数

}

publicvoidRelease（）{

v.removeAllElements（）。

v=null。

imgbullet=null。

sprbullet=null。

}

}

***********Enemy

/**

*

*@authorwizardyx

*/

importjava.io.IOException。

importjava.util.Random。

importjava.util.Vector。

importjavax.microedition.lcdui.Graphics。

importjavax.microedition.lcdui.Image。

importjavax.microedition.lcdui.game.Sprite。

/*

*Tochangethistemplate,chooseTools|Templates

*andopenthetemplateintheeditor.

*/

/*敌人飞机类*/

publicclassEnemy{

privateGameLevelglevel。

//关卡对象

privateImageimgEnemy[]。

//飞机类型图像

privateSprite[]sprEnemy。

//飞机类型精灵数组

privateint[][]path1。

//飞行路径数据

privateint[][]path2。

privateint[][]path3。

privateint[][]path4。

privateint[][]planeInfo。

//敌机数据

privateintstayTimes。

//当前敌机的停留时间

privateintnum。

//下一个要显示在屏幕上的敌机的索引值

privateVectorv。

//v存放当前需要显示敌人的数据数组

privateRandomr。

//随机数，用于计算子弹随机发射

privateEnemyBulletebullet。

//敌机子弹

//Bonusbonus。

//奖励

publicEnemy（GameLevelglevel）{

this.glevel=glevel。

initImage（）。

//初始化图像和精灵

initLevelResource（）。

//初始化关卡资源数据

}

/*初始化图像和精灵*/

privatevoidinitImage（）{

imgEnemy=newImage[5]。

try{

imgEnemy[0]=Image.createImage（"/plane0.png"）。

//小飞机图像

imgEnemy[1]=Image.createImage（"/plane1.png"）。

//直升机图像

imgEnemy[2]=Image.createImage（"/plane2.png"）。

//霰弹机图像

imgEnemy[3]=Image.createImage（"/turret.png"）。

//Boss机炮塔图像

imgEnemy[4]=Image.createImage（"/boss.png"）。

//Boss机图像

}catch（IOExceptionex）{

ex.printStackTrace（）。

}

sprEnemy=newSprite[5]。

sprEnemy[0]=newSprite（imgEnemy[0],16,16）。

//小飞机精灵

sprEnemy[1]=newSprite（imgEnemy[1],26,35）。

//直升机精灵

sprEnemy[2]=newSprite（imgEnemy[2],64,50）。

//霰弹机精灵

sprEnemy[3]=newSprite（imgEnemy[3],15,20）。

//Boss机炮塔精灵

sprEnemy[4]=newSprite（imgEnemy[4],64,40）。

//Boss机精灵

//设置各个精灵的参考点

sprEnemy[0].defineReferencePixel（sprEnemy[0].getWidth（）/2,sprEnemy[0].getHeight（）/2）。

sprEnemy[1].defineReferencePixel（sprEnemy[1].getWidth（）/2,sprEnemy[1].getHeight（）/2）。

sprEnemy[2].defineReferencePixel（sprEnemy[2].getWidth（）/2,sprEnemy[2].getHeight（）/2）。

sprEnemy[3].defineReferencePixel（sprEnemy[3].getWidth（）/2,sprEnemy[3].getHeight（）/2）。

sprEnemy[4].defineReferencePixel（sprEnemy[4].getWidth（）/2,sprEnemy[4].getHeight（）/2）。

}

/*初始化关卡资源*/

privatevoidinitLevelResource（）{

v=newVector（）。

r=newRandom（）。

//路径数据，数组中每个元素记录了该路径点的X坐标，Y坐标，帧ID，停留时间

path2=newint[][]{{200,0,0,0},{200,100,0,50},{100,100,0,0},{200,200,0,20},{200,300,0,0}}。

path3=newint[][]{{20,0,0,0},{20,100,0,0},{200,100,0,0},{200,200,0,0},{200,300,0,0}}。

path1=newint[][]{{0,0,0,0},{100,0,2,0},{100,100,4,0},{200,200,3,0},{240,100,2,0}}。

path4=newint[][]{{0,0,0,0},{100,0,0,0},{100,100,0,0},{200,50,0,0},{100,100,0,0}}。

//飞机数据，数组中每个元素记录了飞机的类别，初始x坐标，初始y坐标，目标点索引，图像帧，速度，间隔/停留时间，路径索引，生命值，飞机所带宝物编号

planeInfo=newint[][]{

{0,0,0,0,0,2,0,0,2,1},{0,0,0,0,0,2,10,0,2,0},{0,0,0,0,0,2,10,0,2,0},{0,0,0,0,0,2,10,0,2,2},

{1,-20,0,0,0,2,0,1,10,1},{1,0,0,0,0,2,100,1,10,0},{1,0,0,0,0,2,120,1,10,3},{1,0,0,0,0,2,120,1,10,0},

{2,0,0,0,0,2,0,2,15,1},{2,0,0,0,0,2,100,2,15,0},{2,0,0,0,0,2,100,2,15,0},{2,0,0,0,0,2,100,2,15,2},

{0,0,0,0,0,2,0,0,2,1},{0,0,0,0,0,2,10,0,2,0},{0,0,0,0,0,2,10,0,2,3},{0,0,0,0,0,2,10,0,2,0},

{1,-20,0,0,0,2,0,1,10,0},{1,0,0,0,0,2,100,1,10,0},{1,0,0,0,0,2,120,1,10,0},{1,0,0,0,0,2,120,1,10,1},

{2,0,0,0,0,2,0,2,15,0},{2,0,0,0,0,2,20,2,15,1},{2,0,0,0,0,2,20,2,15,0},{2,0,0,0,0,2,20,2,15,2},

{4,0,0,0,0,1,0,4,200,0}

}。

stayTimes=0。

//初始化飞机停留时间为0

num=0。

//初始化下一个要显示在屏幕上的飞机的索引值为0

ebullet=newEnemyBullet（）。

}

/*从敌机数据数组中添加1个敌机数据到当前显示的向量v中*/

privatevoidaddNewEnemy（）{

intEnemyData[]=null。

//用于存储1架敌机数据

//从敌机数据数组中获取索引num指定的架敌机数据，并将其加到v2中

if（num

EnemyData=planeInfo[num]。

//获取下一个敌机数据

if（stayTimes>=EnemyData[6]）{//检查下一个敌机的间隔时间是否结束

EnemyData[6]=0。

//清除时间间隔

v.addElement（EnemyData）。

//添加敌机数据到v2

num++。

//更新下一个敌机数据索引

stayTimes=0。

//重置间隔时间

}

stayTimes++。

//敌机间隔时间递增

}

}

/*使v中由索引vID所指定的