基于Java实现的仙剑小游戏

Foooooooood

发布日期: 2020-05-16 12:36:44 浏览量: 1096
评分:
star star star star star star star star star star_border
*转载请注明来自write-bug.com

一、总体概述

1.1 需求分析

此次的游戏项目设定了一个角色玩家李逍遥,用户可以根据键盘的上下左右键来,根据自己的需求来控制角色在场景中的移动。玩家可以根据自己的需求,走到场景中的非角色玩家面前完成对话操作。游戏中提供了两个游戏场景,玩家可以根据自己的需求走到传送门周围,完成场景的切换。

1.2 项目概述

整个游戏项目一共有两个游戏场景。项目为用户提供了一个可控制的角色——李逍遥,玩家可以通过控制键盘上的上下左右键来控制角色在场景中的移动。当角色移动到传送门附近时,用户按下回车键可以完成场景的切换。场景一为李家村场景。用户可以控制角色的上下左右移动在场景中的可跨越区域自由移动。该场景下有一共有七个动态效果的非角色玩家,分别为:阿旺婶,旺财嫂,阿朱,小孩,母鸡,小鸡和小小鸡。当用户控制角色玩家走到非角色人物玩家相应的区域时,可以按下空格键,与其完成对话操作。场景二为李家村市场场景。该场景下,用户同样可以控制角色的上下左右移动在场景中的可跨越区域自由移动。

1.3 开发环境

  • 开发环境:JDK1.7.0

  • 开发语言:Java

  • 开发工具:eclipse

二、详细分析

2.1 功能介绍

  • 自由移动:用户可以通过键盘上的上下左右按键来实现角色在场景上可移动的场景内自由移动

  • 对话:用户可以在靠近非角色人物玩家范围内按下空格键来实现与它的对话

  • 场景切换:用户可以在靠近传送门的区域内按下回车键实现场景一二的来回切换

2.2 核心代码介绍

2.2.1 配角的动态效果实现

先给每个配角定义相应的变量

  1. Image[] awsImages; //定义一个图片数组用来存放所有阿旺婶图片
  2. int awsIndex; //定义表示阿旺婶当前图片对应下标
  3. int awsX;
  4. int awsY;
  5. Image[] azImages;
  6. int azIndex;
  7. int azX;
  8. int azY;
  9. Image[] mjImages;
  10. int mjIndex;
  11. int mjX;
  12. int mjY;
  13. Image[] wcsImages;
  14. int wcsIndex;
  15. int wcsX;
  16. int wcsY;

为每个配角定义的变量初始化,如为配角阿旺婶的变量初始化

  1. awsImages=new Image[17];
  2. //将第i张图片读取保存到数组对应的第i个位置上
  3. //循环次数已知可以使用for循环,未知可以使用while循环
  4. for(int i=0;i<awsImages.length;i++){
  5. //循环存放17张图片
  6. try {
  7. awsImages[i]=ImageIO.read(new File("Legend_of_Sword_and_Fairy/AWangShen/"+i+".png"));
  8. } catch (IOException e) {
  9. // TODO Auto-generated catch block
  10. e.printStackTrace();
  11. }
  12. }
  13. awsIndex=0;
  14. awsX=680;
  15. awsY=580;

在paint()方法中画入配角

  1. g.drawImage(ljcImage,ljcX,ljcY,this);
  2. g.drawImage(lxyImage,lxyX+ljcX,lxyY+ljcY,this);
  3. g.drawImage(awsImages[awsIndex],awsX+ljcX,awsY+ljcY,this);
  4. g.drawImage(azImages[azIndex],azX+ljcX,azY+ljcY,this);
  5. g.drawImage(mjImages[mjIndex],mjX+ljcX,mjY+ljcY,this);
  6. g.drawImage(wcsImages[wcsIndex],wcsX+ljcX,wcsY+ljcY,this);
  7. g.drawImage(xhImages[xhIndex],xhX+ljcX,xhY+ljcY,this);
  8. g.drawImage(xjImages[xjIndex],xjX+ljcX,xjY+ljcY,this);
  9. g.drawImage(xxjImages[xxjIndex],xxjX+ljcX,xxjY+ljcY,this);
  10. g.drawImage(csmImage, csmX+ljcX, csmY+ljcY,csmw,csmh, this);

为了实现动态效果,把配角放入线程中实现图片的循环重复切换,即可完成动态效果。

  1. public void run() {
  2. // TODO Auto-generated method stub
  3. //3.完成方法实现配角的动态效果
  4. while(true){
  5. if(mapID==1){
  6. awsIndex++;
  7. if(awsIndex>=awsImages.length)
  8. awsIndex=0;
  9. azIndex++;
  10. if(azIndex>=azImages.length)
  11. azIndex=0;
  12. mjIndex++;
  13. if(mjIndex>=mjImages.length)
  14. mjIndex=0;
  15. wcsIndex++;
  16. if(wcsIndex>=wcsImages.length)
  17. wcsIndex=0;
  18. xhIndex++;
  19. if(xhIndex>=xhImages.length)
  20. xhIndex=0;
  21. xjIndex++;
  22. if(xjIndex>=xjImages.length)
  23. xjIndex=0;
  24. xxjIndex++;
  25. if(xxjIndex>=xxjImages.length)
  26. xxjIndex=0;
  27. }

2.2.2 主角上下左右移动的实现

定义主角李逍遥相应的变量

  1. Image[] lxyUPImages;
  2. Image[] lxyDownImages;
  3. Image[] lxyLeftImages;
  4. Image[] lxyRightImages;
  5. Image lxyImage;//用来表示李逍遥当前图片内容
  6. int lxyX;
  7. int lxyY;
  8. int lxyIndex;
  9. int lxyDir;

初始化相应的变量

  1. lxyUPImages=new Image[8];
  2. lxyDownImages=new Image[8];
  3. lxyLeftImages=new Image[8];
  4. lxyRightImages=new Image[8];
  5. for(int i=0;i<lxyUPImages.length;i++){
  6. try {
  7. lxyUPImages[i]=ImageIO.read(new
  8. File("Legend_of_Sword_and_Fairy/LiXiaoYao_Up/"+i+".png"));
  9. lxyDownImages[i]=ImageIO.read(new
  10. File("Legend_of_Sword_and_Fairy/LiXiaoYao_Down/"+i+".png"));
  11. lxyLeftImages[i]=ImageIO.read(new
  12. File("Legend_of_Sword_and_Fairy/LiXiaoYao_Left/"+i+".png"));
  13. lxyRightImages[i]=ImageIO.read(new
  14. File("Legend_of_Sword_and_Fairy/LiXiaoYao_Right/"+i+".png"));
  15. } catch (IOException e) {
  16. // TODO Auto-generated catch block
  17. e.printStackTrace();
  18. }
  19. }
  20. lxyImage=lxyDownImages[0];
  21. lxyIndex=0;
  22. lxyX=500;
  23. lxyY=650;
  24. lxyDir=KeyEvent.VK_DOWN;

让GamePanel类继承KeyListener接口,在KeyPress方法中判断用户在键盘上按下的键来实现相应的操作。

  1. if(keycode==38)
  2. {
  3. int x=lxyX+lxyImage.getWidth(null)/2;
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥的边界
  7. if(lxyY<=0) lxyY=0;
  8. lxyY-=5;
  9. lxyIndex++;
  10. if(lxyIndex>=lxyUPImages.length)
  11. lxyIndex=0;
  12. lxyImage=lxyUPImages[lxyIndex];
  13. lxyDir=KeyEvent.VK_UP;
  1. else if(keycode==40)
  2. {
  3. int x=lxyX+lxyImage.getWidth(null)/2;
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥边界问题
  7. if(lxyY>=ljcImage.getHeight(null)-lxyImage.getHeight(null))
  8. lxyY=ljcImage.getHeight(null)-lxyImage.getHeight(null);
  9. lxyY+=5;
  10. lxyIndex++;
  11. if(lxyIndex>=lxyDownImages.length)
  12. lxyIndex=0;
  13. lxyImage=lxyDownImages[lxyIndex];
  14. lxyDir=KeyEvent.VK_DOWN;
  1. else if(keycode==37)
  2. {
  3. int x=lxyX;
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥边界问题
  7. if(lxyX<=0) lxyX=0;
  8. lxyX-=5;
  9. lxyIndex++;
  10. if(lxyIndex>=lxyLeftImages.length)
  11. lxyIndex=0;
  12. lxyImage=lxyLeftImages[lxyIndex];
  13. lxyDir=KeyEvent.VK_LEFT;
  1. else if(keycode==39)
  2. {
  3. int x=lxyX+lxyImage.getWidth(null);
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥边界问题
  7. if(lxyX>=ljcImage.getWidth(null)-lxyImage.getWidth(null))
  8. lxyX=ljcImage.getWidth(null)-lxyImage.getWidth(null);
  9. lxyX+=5;
  10. lxyIndex++;
  11. if(lxyIndex>=lxyRightImages.length)
  12. lxyIndex=0;
  13. lxyImage=lxyRightImages[lxyIndex];
  14. lxyDir=KeyEvent.VK_RIGHT;

在每个if语句里面的最后再加上repaint()方法,主角的动态效果就能实现了。

2.2.3 主角与配角的对话实现

初始化主角与配角的对话内容,如初始化与配角阿旺婶的对话内容

  1. isltawsShow=false;
  2. ltawsString=new String[] {
  3. "李逍遥:阿旺婶,早啊,好久不见!",
  4. "阿旺婶:是逍遥呀,回来啦!",
  5. "李逍遥:是呀,今天刚回来。",
  6. "李逍遥:是呀,今天刚回来。",
  7. "李逍遥:您最近怎么样呀?一切都还好吧?",
  8. "阿旺婶:一切都挺好的嘞!",
  9. "李逍遥:那你先忙,我先走啦!改天再去您家拜访您!",
  10. "阿旺婶:好呀!一定来呀!",
  11. "李逍遥:好的!"};
  12. ltawsIndex=0;

在KeyPress方法中,如果主角走到相应的区域,让对话开始实现。

  1. int x=lxyX+lxyImage.getWidth(null);
  2. int y=lxyY+lxyImage.getHeight(null);
  3. int x2=awsX;
  4. int y2=awsY+awsImages[awsIndex].getHeight(null);
  5. int x1=x2+20; int y1=y2-20;
  6. if(lxyDir==KeyEvent.VK_RIGHT&&x<x1&&x>x2&&y>y1&&y<y2)
  7. {
  8. isltawsShow=true;
  9. }
  1. if(isltawsShow){
  2. //聊天内容切换加聊天结束
  3. int Keycode=e.getKeyCode();
  4. if(Keycode==KeyEvent.VK_SPACE){
  5. ltawsIndex++;
  6. if(ltawsIndex>=ltawsString.length)
  7. {
  8. ltawsIndex=0;
  9. isltawsShow=false;
  10. }
  11. repaint();
  12. }
  13. }
  1. x=lxyX; y=lxyY;
  2. x2=azX+azImages[azIndex].getWidth(null);
  3. y2=azY;
  4. x1=x2-100; y1=y2+100;
  5. if(lxyDir==KeyEvent.VK_UP&&x>x1&&x<x2&&y<y1&&y>y2)
  6. {
  7. isltazShow=true;
  8. }
  1. else if(isltazShow){
  2. int Keycode=e.getKeyCode();
  3. if(Keycode==KeyEvent.VK_SPACE){
  4. ltazIndex++;
  5. if(ltazIndex>=ltazString.length)
  6. {
  7. ltazIndex=0;
  8. isltazShow=false;
  9. }
  10. repaint();
  11. }
  12. }
  1. x=lxyX; y=lxyY+lxyImage.getHeight(null);
  2. x2=wcsX+wcsImages[wcsIndex].getWidth(null);
  3. y2=wcsY+wcsImages[wcsIndex].getHeight(null);
  4. x1=x2-20; y1=y2-20 ;
  5. if(lxyDir==KeyEvent.VK_LEFT&&x>x1&&x<x2&&y>y1&&y<y2)
  6. {
  7. isltwcsShow=true;
  8. }
  1. else if(isltwcsShow) {
  2. int Keycode=e.getKeyCode();
  3. if(Keycode==KeyEvent.VK_SPACE) {
  4. ltwcsIndex++;
  5. if(ltwcsIndex>=ltwcsString.length) {
  6. ltwcsIndex=0;
  7. isltwcsShow=false;
  8. }
  9. repaint();
  10. }
  11. }
  1. x=lxyX+lxyImage.getWidth(null);
  2. y=lxyY+lxyImage.getHeight(null);
  3. x2=xhX;
  4. y2=xhY;
  5. x1=x2+100; y1=y2+100;
  6. if(lxyDir==KeyEvent.VK_RIGHT&&x<x1&&x>x2&&y<y1&&y>y2)
  7. {
  8. isltxhShow=true;
  9. }
  1. else if(isltxhShow) {
  2. int Keycode=e.getKeyCode();
  3. if(Keycode==KeyEvent.VK_SPACE) {
  4. ltxhIndex++;
  5. if(ltxhIndex>=ltxhString.length) {
  6. ltxhIndex=0;
  7. isltxhShow=false;
  8. }
  9. repaint();
  10. }
  11. }
  1. int x=lxyX;int y=lxyY;
  2. int x2=alX;
  3. int y2=alY+alh/2;
  4. int x1=x2+alw;
  5. int y1=y2+alh-10;
  6. if(lxyDir==KeyEvent.VK_UP&&x>x2&&x<x1&&y>y2&&y<y1)
  7. {
  8. isltalShow=true;
  9. }
  1. else if(isltalShow) {
  2. int Keycode=e.getKeyCode();
  3. if(Keycode==KeyEvent.VK_SPACE) {
  4. ltalIndex++;
  5. if(ltalIndex>=ltalString.length) {
  6. ltalIndex=0;
  7. isltalShow=false;
  8. }
  9. repaint();
  10. }
  11. }
  1. x2=xeX; y2=xeY+xeh/2;
  2. x1=x2+xew; y1=y2+xeh;
  3. if(lxyDir==KeyEvent.VK_UP&&x>x2&&x<x1&&y>y2&&y<y1)
  4. {
  5. isltxeShow=true;
  6. }
  1. else if(isltxeShow) {
  2. int Keycode=e.getKeyCode();
  3. if(Keycode==KeyEvent.VK_SPACE) {
  4. ltxeIndex++;
  5. if(ltxeIndex>=ltxeString.length) {
  6. ltxeIndex=0;
  7. isltxeShow=false;
  8. }
  9. repaint();
  10. }
  11. }
  1. x=lxyX+lxyImage.getWidth(null);
  2. y=lxyY;
  3. x1=aziX; y1=aziY;
  4. x2=aziX+20; y2=y1+azih/2;
  5. if(lxyDir==KeyEvent.VK_RIGHT&&x>x1&&x<x2&&y>y1&&y<y2)
  6. {
  7. isltaziShow=true;
  8. }
  1. else if(isltaziShow) {
  2. int Keycode=e.getKeyCode();
  3. if(Keycode==KeyEvent.VK_SPACE) {
  4. ltaziIndex++;
  5. if(ltaziIndex>=ltaziString.length) {
  6. ltaziIndex=0;
  7. isltaziShow=false;
  8. }
  9. repaint();
  10. }
  11. }

2.2.4 主角运动边界的处理

画面的边界处理

  1. //判断处理边界问题
  2. //上下为一组逻辑,左右为一组逻辑,上下中的一个和左右中的一个可能同时出现
  3. if(ljcY>=0)
  4. ljcY=0;
  5. else if(ljcY<=this.getHeight()-ljcImage.getHeight(null))
  6. ljcY=this.getHeight()-ljcImage.getHeight(null);
  7. if(ljcX>=0)
  8. ljcX=0;
  9. else if(ljcX<=this.getWidth()-ljcImage.getWidth(null))
  10. ljcX=this.getWidth()-ljcImage.getWidth(null);

主角边界处理

  1. if(keycode==38)
  2. {
  3. int x=lxyX+lxyImage.getWidth(null)/2;
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥的边界
  7. if(lxyY<=0) lxyY=0;
  8. lxyY-=5;
  1. else if(keycode==40)
  2. {
  3. int x=lxyX+lxyImage.getWidth(null)/2;
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥边界问题
  7. if(lxyY>=ljcImage.getHeight(null)-lxyImage.getHeight(null))
  8. lxyY=ljcImage.getHeight(null)-lxyImage.getHeight(null);
  9. lxyY+=5;
  1. else if(keycode==37)
  2. {
  3. int x=lxyX;
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥边界问题
  7. if(lxyX<=0) lxyX=0;
  8. lxyX-=5;
  1. else if(keycode==39)
  2. {
  3. int x=lxyX+lxyImage.getWidth(null);
  4. int y=lxyY+lxyImage.getHeight(null);
  5. if(mapID==1){
  6. //判断处理李逍遥边界问题
  7. if(lxyX>=ljcImage.getWidth(null)-lxyImage.getWidth(null))
  8. lxyX=ljcImage.getWidth(null)-lxyImage.getWidth(null);
  9. lxyX+=5;

2.2.5 障碍物处理

根据识别用户按下上下左右键时主角是否进入了障碍物区域,来判断是否需要回退操作。

  1. //判断李逍遥是否进入了障碍物区域
  2. if(ljcDataMap.getRGB(x, y)==-521461)
  3. {
  4. lxyX-=5;
  5. }
  6. //判断李逍遥是否进入了障碍物区域
  7. if(ljcDataMap.getRGB(x, y)==-521461)
  8. {
  9. lxyX+=5;
  10. }
  11. //判断李逍遥是否进入了障碍物区域
  12. if(ljcDataMap.getRGB(x, y)==-521461)
  13. {
  14. lxyY-=5;
  15. }
  16. //李逍遥向上移动一次后,如果进入障碍物区域,则需要李逍遥回退操作
  17. if(ljcDataMap.getRGB(x, y)==-521461)
  18. {
  19. lxyY+=5;
  20. }

2.2.6 配角的边界处理

根据识别用户按下上下左右键后主角是否进入了邻近某个配角的区域,来判断是否需要回退操作。

  1. //判断李逍遥向上走的时候是否进入了阿旺婶的边界
  2. int x0=lxyX+lxyImage.getWidth(null)/2;
  3. int y0=lxyY+lxyImage.getHeight(null)/2;
  4. int x1=awsX;int y1=awsY;
  5. int x2=awsX+awsImages[awsIndex].getWidth(null);
  6. int y2=awsY+awsImages[awsIndex].getHeight(null);
  7. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  8. {
  9. lxyY+=5;
  10. }
  11. //判断李逍遥向上走的时候是否进入了阿朱的边界
  12. x0=lxyX; y0=lxyY;
  13. x2=azX+azImages[azIndex].getWidth(null);
  14. y2=azY;
  15. x1=azX-25; y1=y2+80;
  16. if(x0>x1&&x0<x2&&y0>y2&&y0<y1)
  17. {
  18. lxyY+=5;
  19. }
  20. //判断李逍遥向上走的时候是否进入母鸡以及小鸡们的边界
  21. x2=mjX+mjImages[mjIndex].getWidth(null)+20;
  22. y2=mjY+mjImages[mjIndex].getHeight(null);
  23. x1=mjX-20; y1=mjY;
  24. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  25. {
  26. lxyY+=5;
  27. }
  28. //判断李逍遥向上走的时候是否进入了传送门的边界
  29. x0=lxyX+lxyImage.getWidth(null)/2;
  30. y0=lxyY;
  31. x1=csmX-20; y1=csmY+csmh;
  32. x2=csmX+csmw+20; y2=y1+10;
  33. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  34. {
  35. lxyY+=5;
  36. }
  37. //判断李逍遥向上走的时候是否进入了阿兰的边界
  38. int x0=lxyX; int y0=lxyY;
  39. int x2=alX-10; int y2=alY+alh-10;
  40. int x1=alX+alw; int y1=y2+5;
  41. if(x0>x2&&x0<x1&&y0>y2&&y0<y1)
  42. {
  43. lxyY+=5;
  44. }
  45. //判断李逍遥向上走的时候是否进入了小二的边界
  46. x2=xeX-50; y2=xeY+xeh-15;
  47. x1=xeX+xew-10; y1=y2+10;
  48. if(x0>x2&&x0<x1&&y0>y2&&y0<y1)
  49. {
  50. lxyY+=5;
  51. }
  52. //判断李逍遥向上走的时候是否进入了传送门的边界
  53. x0=lxyX+lxyImage.getWidth(null)/2;
  54. y0=lxyY;
  55. x1=csmX-20; y1=csmY+csmh;
  56. x2=csmX+csmw+20; y2=y1+10;
  57. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  58. {
  59. lxyY+=5;
  60. }
  1. //判断李逍遥向下走的时候是否进入了阿旺婶边界区域
  2. int x0=lxyX+lxyImage.getWidth(null)/2;
  3. int y0=lxyY+lxyImage.getHeight(null)/2;
  4. int x1=awsX;int y1=awsY;
  5. int x2=awsX+awsImages[awsIndex].getWidth(null);
  6. int y2=awsY+awsImages[awsIndex].getHeight(null);
  7. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  8. {
  9. lxyY-=5;
  10. }
  11. //判断李逍遥向下走的时候是否进入了旺财嫂的边界区域
  12. x1=wcsX; y1=wcsY;
  13. x2=wcsX+wcsImages[wcsIndex].getWidth(null);
  14. y2=wcsY+wcsImages[wcsIndex].getHeight(null);
  15. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  16. {
  17. lxyY-=5;
  18. }
  19. //判断李逍遥向下走的时候是否进入了小孩边界区域
  20. x1=xhX; y1=xhY;
  21. x2=xhX+xhImages[xhIndex].getWidth(null);
  22. y2=xhY+xhImages[xhIndex].getHeight(null);
  23. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  24. {
  25. lxyY-=5;
  26. }
  27. //判断李逍遥向下走的时候是否进入了传送门的边界
  28. int x0=lxyX+lxyImage.getWidth(null)/2;
  29. int y0=lxyY+lxyImage.getHeight(null);
  30. int x1=csmX-20; int y1=csmY-10;
  31. int x2=csmX+csmw+20; int y2=csmY+10;
  32. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  33. {
  34. lxyY-=5;
  35. }
  1. //判断李逍遥向左走的时候是否进入阿旺婶的边界区域
  2. int x0=lxyX; int y0=lxyY+lxyImage.getHeight(null)/2;
  3. int x1=awsX; int y1=awsY;
  4. int x2=awsX+awsImages[awsIndex].getWidth(null);
  5. int y2=awsY+awsImages[awsIndex].getHeight(null);
  6. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  7. {
  8. lxyX+=5;
  9. }
  10. //判断李逍遥向左走的时候是否进入了旺财嫂的区域
  11. x0=lxyX; y0=lxyY+lxyImage.getHeight(null);
  12. x2=wcsX+wcsImages[wcsIndex].getWidth(null)-5;
  13. y2=wcsY+wcsImages[wcsIndex].getHeight(null)+100;
  14. x1=x2-20; y1=wcsY+20;
  15. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  16. {
  17. lxyX+=5;
  18. }
  19. //判断李逍遥向左走的时候是否进入了传送门边界
  20. x0=lxyX; y0=lxyY;
  21. x2=csmX+csmw;
  22. y2=csmY+csmh+5;
  23. x1=csmX; y1=csmY-20;
  24. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  25. {
  26. lxyX+=5;
  27. }
  28. //判断李逍遥向左走的时候是否进入阿兰的边界
  29. int x0=lxyX; int y0=lxyY;
  30. int x1=alX; int y1=alY;
  31. int x2=alX+alw; int y2=alY+alh;
  32. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  33. {
  34. lxyX+=5;
  35. }
  36. //判断李逍遥向左走的时候是否进入小二的边界
  37. x1=xeX; y1=xeY;
  38. x2=xeX+xew; y2=xeY+xeh;
  39. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  40. {
  41. lxyX+=5;
  42. }
  43. //判断李逍遥向左走的时候是否进入传送门边界
  44. x0=lxyX; y0=lxyY;
  45. x2=csmX+csmw;
  46. y2=csmY+csmh+5;
  47. x1=csmX; y1=csmY-100;
  48. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  49. {
  50. lxyX+=5;
  51. }
  1. //判断李逍遥向右走的时候是否进入了阿旺婶边界区域
  2. int x0=lxyX+lxyImage.getWidth(null);
  3. int y0=lxyY+lxyImage.getHeight(null);
  4. int x2=awsX+5;
  5. int y2=awsY+awsImages[awsIndex].getHeight(null)+50;
  6. int x1=awsX+awsImages[awsIndex].getWidth(null)-25;
  7. int y1=awsY+25;
  8. if(x0<x1&&x0>x2&&y0>y1&&y0<y2)
  9. {
  10. lxyX-=5;
  11. }
  12. //判断李逍遥向右走的时候是否进入了小孩边界区域
  13. x0=lxyX+lxyImage.getWidth(null);
  14. y0=lxyY+lxyImage.getHeight(null);
  15. x2=xhX+20; y2=xhY+20;
  16. x1=x2+100; y1=xhY+xhImages[xhIndex].getHeight(null)+20;
  17. if(x0>x2&&x0<x1&&y0>y2&&y0<y1)
  18. {
  19. lxyX-=5;
  20. }
  21. //判断李逍遥向右走的时候是否进入了传送门的边界
  22. x0=lxyX+lxyImage.getWidth(null);
  23. y0=lxyY;
  24. x1=csmX-5; y1=csmY-20;
  25. x2=csmX+10; y2=csmY+csmh+20;
  26. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  27. {
  28. lxyX-=5;
  29. }
  30. //判断李逍遥向右走的时候是否进入了小二的边界
  31. int x0=lxyX+lxyImage.getWidth(null); int y0=lxyY;
  32. int x1=xeX; int y1=xeY-20;
  33. int x2=xeX+xew; int y2=xeY+xeh+10;
  34. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  35. {
  36. lxyX-=5;
  37. }
  38. //判断李逍遥向右走时是否进入阿紫的边界
  39. x0=lxyX+lxyImage.getWidth(null);
  40. y0=lxyY;
  41. x1=aziX+5; y1=aziY;
  42. x2=aziX+aziw; y2=aziY+azih;
  43. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  44. {
  45. lxyX-=5;
  46. }
  47. //判断李逍遥向右走的时候是否进入了传送门的边界
  48. x0=lxyX+lxyImage.getWidth(null);
  49. y0=lxyY;
  50. x1=csmX-5; y1=csmY-100;
  51. x2=csmX+10; y2=csmY+csmh+20;
  52. if(x0>x1&&x0<x2&&y0>y1&&y0<y2)
  53. {
  54. lxyX-=5;
  55. }

2.2.7 主角切换场景的实现

通过mapID变量来确定当前的场景,当主角走到传送门附近区域时,用户按下回车键可以达到场景切换的效果。

  1. //判断处理是否进行切换场景
  2. else if(keycode==KeyEvent.VK_ENTER){
  3. int x0=lxyX; int y0=lxyY;
  4. int x2=csmX+csmw+5;
  5. int y2=csmY+csmh+5;
  6. int x1=csmX; int y1=csmY-10;
  7. if(mapID==1){
  8. if(x0>x1&&x0<x2&&y0>y1&&y0<y2){
  9. mapID=2;
  10. }
  11. }
  12. else if(mapID==2){
  13. if(x0>x1&&x0<x2&&y0>y1&&y0<y2){
  14. mapID=1;
  15. }
  16. }

2.2.8 打开窗口和关闭窗口之前的弹窗

  1. window.addWindowListener(new WindowAdapter(){
  2. //当窗口打开的时候会执行该方法
  3. public void windowOpened(WindowEvent e) {
  4. // TODO Auto-generated method stub
  5. super.windowOpened(e);
  6. //输入对话框
  7. //String xinxi=JOptionPane.showInputDialog(null,"请输入内容:");
  8. //消息对话对话框
  9. JOptionPane.showMessageDialog(null,
  10. "欢迎来到仙剑之初始!你的游戏角色为李逍遥。");
  11. }
  12. //当窗口正在关闭的时候它会自动执行该方法
  13. public void windowClosing(WindowEvent e) {
  14. super.windowClosing(e);
  15. //呈现出一个退出确认对话框
  16. int jieguo=JOptionPane.showConfirmDialog(null, "真的真的要离开吗?!",
  17. "退出确认",JOptionPane.YES_NO_OPTION);
  18. //根据玩家选择按钮进行对应的操作
  19. if(jieguo==JOptionPane.YES_OPTION)
  20. {
  21. System.exit(0);
  22. }
  23. }
  24. });

三、测试分析

3.1 功能测试展示

主角的上下左右移动

主角与配角对话

场景切换

开启窗口后的弹窗效果

关闭窗口前的弹窗效果

四、问题总结

4.1 不足

整个游戏项目目前主要还存在以下几个问题:

  • 功能不够丰富。用户能通过控制键盘实现主角在有效区域内自由移动,还能实现和配角的对话以及完成场景的切换,除此之外就没有其他的功能。作为一个游戏项目只是具备了很基础的功能,很多其他的附加功能还需要去丰富。

  • 如果用户让主角走入某些边角的无效区域,容易陷入卡死的情况,很有可能就出不来。

  • 与用户对话的语句只能逐句显示,换行和翻页的功能还没有实现。

  • 游戏的一些配角的图效并没有很完善,配角的动态效果只做了一部分。

4.2 总结

这次的游戏开发项目历时八周,从对游戏开发一无所知到如今小游戏开发项目的完成,学习了很多,也收获了很多。

这一次的项目开发,使用了Java语言,整个流程下来最明显的进步就是Java语言的使用熟练度得到了大大的提升。这一次的项目让我学到了,了解到了,认识到了许多之前没有接触过的关于绘图的一些类和接口,相信这些知识对我以后一定会有极大的帮助。

上传的附件 cloud_download 基于Java实现的仙剑小游戏.7z ( 22.82mb, 19次下载 )
error_outline 下载需要10点积分

发送私信

一盏灯,一条路,一个你

14
文章数
27
评论数
最近文章
eject