用J2ME实现扫雷

最新推荐文章于 2024-04-15 08:10:40 发布
最新推荐文章于 2024-04-15 08:10:40 发布
阅读量3.1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 学习日记 文章标签： j2me byte 游戏 command import random
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ntwilford/article/details/1337264
本文介绍了一个基于J2ME平台的简易扫雷游戏实现，包括游戏逻辑、UI设计及核心类的功能说明。通过四个主要类：MineGame、MineBoard、MineMIDlet和MineDefs，实现了基本的游戏功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 
这学期J2ME告一段落了，没学到什么东西，老师已经让交作业了。时间太紧写个扫雷凑数。
写了四个类：
MineGame: 处理游戏逻辑
MineBoard: 游戏的面板（canvas）
MineMIDlet: MIDlet主类,启动游戏，调度游戏面板
MineDefs: 没别的作用，就是定义一些常量，供其它类使用。
 
下面是MineDefs类,各常量的意思从字面就能看出来
//MineDefs: 定义常量
public class MineDefs
{
      //雷方块状态
      public static final byte STATE_FLAG_MINE =0;
      public static final byte STATE_NORMAL_MINE =1;
      public static final byte STATE_FLAG_EMPTY    =2;
      public static final byte STATE_NORMAL_EMPTY   =3;
      public static final byte STATE_OPEN_0         =8;
      public static final byte STATE_OPEN_1         =9;
      public static final byte STATE_OPEN_2         =10;
      public static final byte STATE_OPEN_3         =11;
      public static final byte STATE_OPEN_4         =12;
      public static final byte STATE_OPEN_5         =13;
      public static final byte STATE_OPEN_6         =14;
      public static final byte STATE_OPEN_7         =15;
      public static final byte STATE_OPEN_8         =16;
      public static final byte STATE_OVER_BLAST    =26;
      public static final byte STATE_OVER_MINE =28;
     
      //游戏状态
      public static final byte GAMESTATE_RUN         =1;
      public static final byte GAMESTATE_OVER       =2;
      public static final byte GAMESTATE_WIN          =3;
     
      public static final byte HASOPENED              =100;
      public static final byte DONTEXPAND                =101;
      public static final byte WRONGMINENUM         =102;
     
      //格子数与雷数
      public static final byte GRIDNUM_X              =9;
      public static final byte GRIDNUM_Y              =9;
      public static final byte MINENUM            =10;
}
MineMIDlet主类,有两个按钮，退出和重新开始
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
 
public class MineMIDlet extends MIDlet implements CommandListener
{
      Display display;
      MineBoard gameCanvas;
      MineGame game;
     
      Command cmdExit=new Command("退出",Command.EXIT,0);
      Command cmdRestart=new Command("重新开始",Command.OK,1);
     
      public void startApp() throws MIDletStateChangeException
     {
         display = Display.getDisplay(this);
        
         game=new MineGame();
         gameCanvas=new MineBoard(game);
         gameCanvas.addCommand(cmdExit);
         gameCanvas.addCommand(cmdRestart);
         gameCanvas.setCommandListener(this);
        
         display.setCurrent(gameCanvas);
     }
 
     public void pauseApp(){ }
     public void destroyApp(boolean unconditional){ notifyDestroyed(); }
    
     public void commandAction(Command c, Displayable d)
     {
          if(c.equals(cmdExit))
          {
                destroyApp(false);
          }
          else
          {
                game.restart();
                gameCanvas.repaint();
          }
     }
 
}
 
下面是最关键的两个类
import javax.microedition.lcdui.*;
MineBoard:游戏的面板 同时处理按键
public class MineBoard extends Canvas
{
      private int scrWidth,scrHeight;      
      private int boardWidth,boardHeight;         //雷区宽高
      private int boardLeft,boardTop;
      private int gridWidth;                //格子的边长
      private byte curPosX=0; //光标位置
      private byte curPosY=0;
      private String extraInfo="";
      private MineGame game;
     
      public MineBoard(MineGame game)
      {    //在构造函数中计算布局
           this.game=game;
           scrWidth=getWidth();
           scrHeight=getHeight();
           int tmpgridWidth=scrWidth/MineDefs.GRIDNUM_X;
           int tmpgridHeight=scrHeight/MineDefs.GRIDNUM_Y;
           if(tmpgridWidth<tmpgridHeight)
           {
                 gridWidth=tmpgridWidth;
                 boardWidth=gridWidth*MineDefs.GRIDNUM_X;
                 boardHeight=gridWidth*MineDefs.GRIDNUM_Y;
                 boardLeft=0;
                 boardTop=scrHeight-boardHeight;
           }
           else
           {
                 gridWidth=tmpgridHeight;
                 boardWidth=gridWidth*MineDefs.GRIDNUM_X;
                 boardHeight=gridWidth*MineDefs.GRIDNUM_Y;
                 boardLeft=scrWidth-boardWidth;
                 boardTop=0;
           }
      }
     
      public void paint(Graphics g)
      {
           g.setColor(150,150,255);     //清屏
           g.fillRect(0,0,scrWidth,scrHeight);
           //画游戏状态
           String state="";
           switch(game.getGameState())
           {
                 case MineDefs.GAMESTATE_OVER:
                      state="失败";
                      break;
                 case MineDefs.GAMESTATE_WIN:
                      state="胜利";
                      break;
           }
           if(scrWidth<scrHeight)
           {
                 g.setColor(255,0,0);
                 g.drawString(state,0,0,Graphics.LEFT|Graphics.TOP);
                 g.drawString("还有"+game.getMinesRemain()+"颗雷",30,0,Graphics.LEFT|Graphics.TOP);
                 g.drawString(extraInfo,0,10,Graphics.LEFT|Graphics.TOP);
           }
           //画雷区
            g.translate(boardLeft,boardTop);//调整起点
           for(byte i=0;i<MineDefs.GRIDNUM_X;++i)
           {
                 for(byte j=0;j<MineDefs.GRIDNUM_Y;++j)
                 {
                      drawGrid(i,j,game.getGridState(i,j),g);
                 }
           }
           //画光标
           g.setColor(255,0,0);
           g.drawRect(curPosX*gridWidth+1,curPosY*gridWidth+1,gridWidth-2,gridWidth-2);
      }
      //画每个雷方格的函数，如果需要可以修改这里让界面更好看
      private void drawGrid(byte x,byte y,byte gridState,Graphics g)
      {g.setColor(0,0,0);
           switch(gridState)
           {
                 case MineDefs.STATE_FLAG_MINE:
                 case MineDefs.STATE_FLAG_EMPTY://有标记
                       g.setColor(0,0,0);
                      g.fillRect(x*gridWidth,y*gridWidth,gridWidth,gridWidth);
                      break;
                 case MineDefs.STATE_NORMAL_MINE:
                 case MineDefs.STATE_NORMAL_EMPTY:   //正常未打开
                      g.setColor(255,255,255);
                      g.fillRect(x*gridWidth,y*gridWidth,gridWidth,gridWidth);
                      break;
                 case MineDefs.STATE_OPEN_0:
                       //g.drawString("0",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      g.setColor(255,255,0);
                      g.fillRect(x*gridWidth,y*gridWidth,gridWidth,gridWidth);
                      break;
                 case MineDefs.STATE_OPEN_1:
                       g.drawString("1",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_2:
                       g.drawString("2",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_3:
                       g.drawString("3",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_4:
                       g.drawString("4",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_5:
                       g.drawString("5",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_6:
                       g.drawString("6",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_7:
                       g.drawString("7",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OPEN_8:
                       g.drawString("8",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OVER_BLAST:
                       g.drawString("B",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
                 case MineDefs.STATE_OVER_MINE:
                       g.drawString("M",x*gridWidth+7,y*gridWidth,Graphics.HCENTER|Graphics.TOP);
                      break;
           }
      }
     
      protected void keyPressed(int key)
      {//处理键盘事件
           if(game.getGameState()!=MineDefs.GAMESTATE_RUN)
                 return;
           extraInfo="";
           switch ( getGameAction(key) )
           {
                 case Canvas.UP:
                      if(curPosY>0)
                      {
                            --curPosY;
                            repaint();
                      }
                      break;
                 case Canvas.DOWN:
                      if(curPosY<MineDefs.GRIDNUM_Y-1)
                      {
                            ++curPosY;
                            repaint();
                      }
                      break;
                 case Canvas.LEFT:
                      if(curPosX>0)
                      {
                            --curPosX;
                            repaint();
                      }
                      break;
                 case Canvas.RIGHT:
                      if(curPosX<MineDefs.GRIDNUM_X-1)
                      {
                            ++curPosX;
                            repaint();
                      }
                      break;
                 case Canvas.GAME_A://数字1键(切换标记)
                      //System.out.println ("标记");
                      if(game.flagGrid(curPosX,curPosY)==MineDefs.WRONGMINENUM)
                      {
                            extraInfo="雷数目不正确";
                      }
                      repaint();
                      break;
                 case Canvas.GAME_B://数字3键(展开区域)
                      //System.out.println ("拓展");
                      if(game.expand(curPosX,curPosY)==MineDefs.DONTEXPAND)
                      {//不允许扩展
                            extraInfo="不允许扩展";
                      }
                      repaint();
                      break;
                 case Canvas.FIRE:    //打开格子
                      //System.out.println ("打开");
                      if(game.hitGrid(curPosX,curPosY)==MineDefs.HASOPENED)
                      {
                            extraInfo="已经打开";
                      }
                      repaint();
                      break;
           }
      }
}
 
MineGame:游戏的核心逻辑
import java.util.*;
 
public class MineGame
{
      //表示雷区的二维数组
      private byte mines[][]=new byte[MineDefs.GRIDNUM_X][MineDefs.GRIDNUM_Y];
      private byte gameState;
      private byte minesRemain=0;
     
      public MineGame()
      {
           restart();
      }
     
      //游戏重新开始
      public void restart()
      {//System.out.println ("重新开始");
           minesRemain=0;
           clearMines();
           layMines();
           gameState=MineDefs.GAMESTATE_RUN;
      }
     
      //清空雷区
      private void clearMines()
      {
           for(byte i=0;i<MineDefs.GRIDNUM_X;++i)
           {
                 for(byte j=0;j<MineDefs.GRIDNUM_Y;++j)
                 {
                      mines[i][j]=MineDefs.STATE_NORMAL_EMPTY;
                 }
           }
      }
     
      //随即布置雷
      private void layMines()
      {
           Random random = new Random(Calendar.getInstance().getTime().getTime());
           int x,y;
           for(byte i=0;i<MineDefs.MINENUM;)
           {
                 x = Math.abs(random.nextInt()) % MineDefs.GRIDNUM_X;
              y = Math.abs(random.nextInt()) % MineDefs.GRIDNUM_Y;
              if(mines[x][y]>MineDefs.STATE_NORMAL_MINE)//后面的状态均表示无雷
              {
                   mines[x][y]=MineDefs.STATE_NORMAL_MINE;
                   ++minesRemain;
                   ++i;
              }
           }
           //dis();
      }
//    public void dis()
//    {
//         //输出雷区状态
//         for(byte i=0;i<MineDefs.GRIDNUM_Y;++i)
//         {
//               for(byte j=0;j<MineDefs.GRIDNUM_X;++j)
//               {
//                    System.out.print (mines[j][i]+" ");
//               }
//               System.out.println ();
//         }
//    }
     
      //获取方块的状态
      public byte getGridState(byte x,byte y)
      {
           return mines[x][y];
      }
     
      public byte getGameState()
      {
           return gameState;
      }
     
      public byte getMinesRemain()
      {
           return minesRemain;
      }
      //计算周围有多少雷
      private byte getAroundMine(byte x,byte y)
      {
           byte num=0;
           byte minX=(byte)((x==0)? 0:x-1);
           byte maxX=(byte)((x==MineDefs.GRIDNUM_X-1)? MineDefs.GRIDNUM_X-1:x+1);
           byte minY=(byte)((y==0)? 0:y-1);
           byte maxY=(byte)((y==MineDefs.GRIDNUM_Y-1)? MineDefs.GRIDNUM_Y-1:y+1);
           for(int i=minX;i<=maxX;++i)
           {
                 for(int j=minY;j<=maxY;++j)
                 {
                      if(mines[i][j]<=MineDefs.STATE_NORMAL_MINE)//此前状态均为有雷
                            ++num;
                 }
           }
           return num;
      }
     
      //计算周围作了几个标记
      private byte getAroundFlag(byte x,byte y)
      {
           byte num=0;
           byte minX=(byte)((x==0)? 0:x-1);
           byte maxX=(byte)((x==MineDefs.GRIDNUM_X-1)? MineDefs.GRIDNUM_X-1:x+1);
           byte minY=(byte)((y==0)? 0:y-1);
           byte maxY=(byte)((y==MineDefs.GRIDNUM_Y-1)? MineDefs.GRIDNUM_Y-1:y+1);
           for(int i=minX;i<=maxX;++i)
           {
                 for(int j=minY;j<=maxY;++j)
                 {
                       if(mines[i][j]==MineDefs.STATE_FLAG_MINE||mines[i][j]==MineDefs.STATE_FLAG_EMPTY)//有标记的
                            ++num;
                 }
           }
           return num;
      }
     
      //打开一个雷方块
      public byte hitGrid(byte x,byte y)   //返回游戏状态
      {//System.out.println (x+" "+y+" "+mines[x][y]);
           if(mines[x][y]>=MineDefs.STATE_OPEN_0)//此处已经打开
           {//System.out.println (x+" "+y+" "+mines[x][y]+" "+MineDefs.STATE_OPEN_0+"此处已经打开");
                 return MineDefs.HASOPENED;    
           }
           if(mines[x][y]<=MineDefs.STATE_NORMAL_MINE)//点中了地雷
           {//System.out.println (x+" "+y+" "+mines[x][y]+" "+MineDefs.STATE_NORMAL_MINE+"点中了地雷");
                 gameState=MineDefs.GAMESTATE_OVER;
                 for(byte i=0;i<MineDefs.GRIDNUM_X;++i)
                 {
                      for(byte j=0;j<MineDefs.GRIDNUM_Y;++j)
                      {
                            if(mines[i][j]<=MineDefs.STATE_NORMAL_MINE)//此前状态均为有雷
                                  mines[i][j]=MineDefs.STATE_OVER_MINE;
                      }
                 }
                 mines[x][y]=MineDefs.STATE_OVER_BLAST;
           }
           else     //未点中地雷，改变相应状态
           {//System.out.println (x+" "+y+" "+mines[x][y]+" "+"未点中地雷");
                 byte aroundNum=getAroundMine(x,y);//System.out.println (x+" "+y+" "+mines[x][y]+"周围有"+aroundNum);
                 mines[x][y]=(byte)(MineDefs.STATE_OPEN_0+aroundNum);//System.out.println (x+" "+y+" "+mines[x][y]);
                 if(aroundNum==0)    //周围没有雷 拓展
                 {//System.out.println (x+" "+y+" "+mines[x][y]+"拓展");
                      expand(x,y);
                 }
           }
           return gameState;
      }
     
      //标记一个雷方块
      public byte flagGrid(byte x,byte y)
      {
           if(mines[x][y]>=MineDefs.STATE_OPEN_0)//此处已经打开
                 return MineDefs.HASOPENED;    
            if(mines[x][y]==MineDefs.STATE_FLAG_MINE||mines[x][y]==MineDefs.STATE_FLAG_EMPTY)//原有标记
           {
                 ++mines[x][y];     //转换到对应的无标记状态
                 ++minesRemain;//System.out.println ("还有雷"+minesRemain);
                 if(isVictory())
                 {
                      gameState=MineDefs.GAMESTATE_WIN;
                 }
           }
           else     //原无标记
           {
                 if(minesRemain<=0)
                      return MineDefs.WRONGMINENUM;
                 --mines[x][y];
                 --minesRemain;//System.out.println ("还有雷"+minesRemain);
                 if(isVictory())
                 {
                      gameState=MineDefs.GAMESTATE_WIN;
                 }
           }
           return gameState;
      }
     
      //拓展方块（如果此方块周围没有类,或雷已标记）
      public byte expand(byte x,byte y)
      {
           byte aroundNum=getAroundMine(x,y);
           if(aroundNum!=getAroundFlag(x,y))//没有标完雷不允许展开
                 return MineDefs.DONTEXPAND;
           byte minX=(byte)((x==0)? 0:x-1);
           byte maxX=(byte)((x==MineDefs.GRIDNUM_X-1)? MineDefs.GRIDNUM_X-1:x+1);
           byte minY=(byte)((y==0)? 0:y-1);
           byte maxY=(byte)((y==MineDefs.GRIDNUM_Y-1)? MineDefs.GRIDNUM_Y-1:y+1);
           for(byte i=minX;i<=maxX;++i)
           {
                 for(byte j=minY;j<=maxY;++j)
                 {
                       if(mines[i][j]==MineDefs.STATE_NORMAL_MINE||mines[i][j]==MineDefs.STATE_NORMAL_EMPTY)
                            hitGrid(i,j);
                 }
           }
           return gameState;
      }
     
      //判断游戏是否胜利
      private  boolean isVictory()
      {
           if(minesRemain>0)
           {
                 return false;
                
           }//System.out.println ("标完");
           for(byte i=0;i<MineDefs.GRIDNUM_X;++i)
           {
                 for(byte j=0;j<MineDefs.GRIDNUM_Y;++j)
                 {
                      if(mines[i][j]==MineDefs.STATE_FLAG_EMPTY)//此前状态均为有雷
                            return false;
                 }
           }
           return true;
      }
}
 
这个扫雷具有最基本的游戏功能，如果需要，可以方便的添加其它附加功能，比如使用RMS保存游戏记录，或者加上声音。
 
J2ME-MIDP1.0游戏完整实现-双人扫雷1.0（一）
yinowl的专栏
02-13 1255
作者：yinowl2005年2月前言我的上一篇也是第一篇文章《J2ME-MIDP1.0小游戏入门-五子棋》贴出以后，有好多的朋友发邮件、加QQ、加MSN和我聊有关J2ME的内容，我很开心也很感慨，开心并不是因为自己文章写得如何如何而有很多人联系我，而是有这么多的朋友在学J2ME，我原来以为现在已经没有人再会联系文章的作者，看来我错了；感慨是因为，我知道我的第一篇文章其实很差的，从大家的反应，我
MinGW+Lua环境配置小结
wilford的专栏
07-31 6245
    虽说VC是Windows下C++开发的首选工具，但有时候写一些小程序，我还是更倾向于使用一些轻量级的开发工具。比如最近研究Lua嵌入C++，有时候只是写一些很小的程序，这时候Visual Studio就显得太过臃肿了，于是我选择了EditPlus+MinGW的方法。搞了两个晚上，终于搭建好了环境，在这里总结一下，以备将来查看。    MinGW的安装比较简单了。我偷懒直接下了个自动安装
Java j2me版扫雷代码.rar
07-10
Java j2me版扫雷代码,不多介绍了，类似代码觉得有不少可以参考，这是早几年运行在手机上的版本，不是Android版本。
j2me-扫雷
lshln的专栏
07-18 680
<br />　　2010/7/18日，用了几天写了个j2me版的扫雷，源码上传了，我在这里主要是想记录下我当时做的思路。<br />一开始，我先想把图画出来，比如9*9中，这里我用二维数组array1[9][9]表示，那这9*9中有10个雷，我用array[10]表示。<br /> <br />这array[10]里面放的是二维数组的下标，这个下标应该是随机的。于是在这是我写了一个产生随机数的java类。<br />在这是产生随机数的类，我采用的是在一个已有的数组中随机一个，标记后把它放到数组最后，长度减一
j2me 实现的扫雷游戏
weixin_30924239的博客
07-25 105
一、 利用j2me实现windows自带的扫雷游戏。实现过程主要用的知识点： 1、MIDlet实现入口，控制屏幕和命令的控制。 2、数组，侦听接口，线程，简单的算法。 二、 具体的实现过程： 入口类的实现：import javax.microedition.lcdui.*; import javax.microedition.midlet.*; public cla...
j2me-扫雷-上传的是一个工程，netbean6.5导入直接可以用
07-18
j2me 扫雷　上传的是一个工程，netbean6.5导入直接可以用
java实现简单窗口小游戏“扫雷”
最新发布
2401_84049282的博客
04-15 1458
给大家送一个小福利附高清脑图，高清知识点讲解教程，以及一些面试真题及答案解析。送给需要的提升技术、准备面试跳槽、自身职业规划迷茫的朋友们。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！茫的朋友们。[外链图片转存中…(img-QCfRkLAG-1713139827019)]《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
J2ME-MIDP1.0游戏完整实现-双人扫雷1.0（一）(转)
02-13 1723
作者：yinowl2005年2月前言我的上一篇也是第一篇文章《J2ME-MIDP1.0小游戏入门-五子棋》贴出以后，有好多的朋友发邮件、加QQ、加MSN和我聊有关J2ME的内容，我很开心也很感慨，开心并不是因为自己文章写得如何如何而有很多人联系我，而是有这么多的朋友在学J2ME，我原来以为现在已经没有人再会联系文章的作者，看来我错了；感慨是因为，我知道我的第一篇文章其实很差的，从大家的反应，我
[转载]MIDP1.0游戏完整实现-双人扫雷1.0（一）
congji3817的博客
07-12 362
MIDP1.0游戏完整实现-双人扫雷1.0（一）前言我的上一篇也是第一篇文章《J2ME-MIDP1.0小游戏入门-五子棋》贴出以后，有好多的朋友发邮件、加QQ、加MSN和我聊有关J2ME的内容，我很开心也很感慨，开心并不是因为自...
扫雷源代码刨析(J2ME)
Cave-House
08-14 2887
扫雷源代码刨析 注意：源代码仅供个人作学习研究时的参考，不得在程序制作中直接抄录。    源代码一共两个文件：Mine.java，MGame.java，另外还有一些图片。    在JBuilder下建立一个新的工程，将两个源文件复制到工程目录下的src/mine目录中，将所有图片复制到src/images目录中就可以了。 要点分析数据结构    首先要说明一下用来存放地雷信
J2ME伪高手先锋开讲——扫雷游戏的设计
vgame的专栏
04-09 836
J2ME伪高手先锋开讲——扫雷游戏的设计   首先我要装得像高手一样,来假装把系统稍微分析一下。一般，按照java得开发模式，这种程序一般是分为三个模块来开发。如下三个：一个程序运作的主文件，也就是一个midlet的继承；一个界面的表示类，也就是一个canvas的继承，界面上应该有些菜单，如new、exit 什么的，那就应该要 implements一个 commandListene
J2ME手机扫雷游戏
06-05
【J2ME手机扫雷游戏】是一款基于Java Micro Edition（J2ME）平台开发的移动端经典游戏，旨在在小型设备上重现PC版本的扫雷体验。J2ME是Java技术的一个分支，主要用于嵌入式系统和移动设备，如早期的智能手机和平板...
J2ME手机扫雷游戏源代码
03-14
在J2ME中，事件处理是通过实现CommandListener接口或使用Displayable的notifyCommandAction方法完成的。玩家点击屏幕上的格子，会触发事件，游戏需要正确响应这些事件，更新游戏状态并显示结果。 5. **用户界面** ...
基于J2ME的扫雷游戏设计与实现
在 Java 扫雷游戏设计中，我们使用 J2ME 平台的 canvas 组件来实现游戏界面，使用 Java 语言来实现游戏逻辑和游戏数据存储。我们还使用了 Random 类来生成游戏板中的随机数，使用了 Math 类来处理游戏中的数学运算。...
C++的成员指针
wilford的专栏
12-16 5814
     如果不是读《C++编程思想》，恐怕我到今天也不会知道成员指针这东西，真是让我大开了眼界。按我的理解，普通指针指向的地址是相对于整个内存空间的，而成员指针并不包含真实的地址，它实际上代表了一个成员在其类范围内的相对位置。一个小程序可以解释成员指针的用法。#include using namespace std; cl
基于Direct3D实现简单的粒子系统
wilford的专栏
09-12 5814
      这是一个基于D3D的基本的粒子系统，能够实现一些基本的效果，如：雨、雪、烟花等。代码很少，只有一个头文件和一个CPP文件，便于研究粒子系统的原理。EpParticleSystem.h:#ifndef _EPPARTICLESYSTEM_H_ #define _EPPARTICLESYSTEM_H_ #inc
Ogre中的动画混合(AnimationBlender)
wilford的专栏
12-31 5759
 网上Ogre的中文资料真的是很少啊，把自己学到的分享出来，希望能对初学者有所帮助。Ogre中实现骨骼动画真的是再简单不过了，就两个函数：getAnimationState，addTime。OK，人物就可以动起来了。这个AnimationBlender类可以实现以多种方式从一个动画淡入到另一个动画，来自于Ogre网站上的一篇文章。但那位老外只贴出了代码，没有讲解，甚至代码中也没有详尽的注释
简单的八方向寻路算法
wilford的专栏
06-14 4110
 前几天在图书馆借了一本《游戏程序设计概论》，发现这本书还不错，对游戏有个大概的介绍。学了里面的四方向等高线寻路算法后，把它改成了八方向。大概原理是，从目的点开始向周围一步一步扩展，知道遇到起始点为止。用到了两个队列，一个作为源，一个作为目的。先把目的点放入源队列，在将目的点向八个方向扩展，并放入目的队列，然后交换源与目的，再将源队列中的点向周围扩展，并放入目的队列，如此循环，知道遇到起始点。标记
基于Direct3D实现简单的粒子系统(二) - 增加LUA脚本支持
wilford的专栏
09-14 3708
      之前已经创建了一个简单的粒子系统（点这里），但是使用起来还是不是很方便，这次的任务就是为这个系统增加脚本支持。使用脚本来定义粒子系统的各项属性，再从主程序中将这些属性读出来，创建粒子系统。我对小巧简洁的东西有种特殊的喜好，因此我选择了Lua语言。Lua与C的交互需要频繁的操作栈，使用起来并不是很方便，因此先简单的封装一下，可以不用直接操作栈就可以了。      下面的这
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值