介绍一个游戏开始的画面。
先建两个类 MenuScreen.java  SimpleCustomMenuWithBGFont.java用于测试

首先说下SimpleCustomMenuWithBGFont.java

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
//import java.util.*;

public class SimpleCustomMenuWithBGFont extends MIDlet implements CommandListener {

  Display display;
  Display pauseDisplay;
  boolean isSplash = true;
  MenuScreen menuScreen;

  public SimpleCustomMenuWithBGFont() {
    MenuScreen menuScreen = new MenuScreen();
    display = Display.getDisplay(this);
    display.setCurrent(menuScreen);
  }

  protected void startApp() throws MIDletStateChangeException   {
  }

  protected void pauseApp() {  }
  protected void destroyApp (boolean flag) throws MIDletStateChangeException {}

  public void commandAction (Command cmd, Displayable dis) {

  }
}
这个类很简单,就是作为了测试使用的。

主要来介绍一下MenuScreen.java

import javax.microedition.lcdui.*;

public class MenuScreen extends Canvas implements Runnable {

  // 设置字体
  static final Font lowFont  = Font.getFont (Font.FACE_MONOSPACE, Font.STYLE_PLAIN, Font.SIZE_SMALL);
  static final Font highFont = Font.getFont (Font.FACE_MONOSPACE, Font.STYLE_BOLD, Font.SIZE_MEDIUM);
  static final int NEW_GAME = 0;
    static final int HIGH_SCORE = 1;
    static final int SETTINGS = 2;
    static final int HELP = 3;
    static final int ABOUT = 4;
    static final int MENU_ITEM_COUNT = 5;

  // 设置颜色
  static final int lowColor  = 0x0000FF00;    // Not Highlighted
  static final int highColor = 0x000000FF;    // Highlighted
  static final int highBGColor = 0x00CCCCCC;  // Highlighted Background

  static int width;   //屏幕宽
  static int height;  // 屏幕高

  static int startHeight;  // 菜单开始的高度

  static final int spacing = highFont.getHeight()/2;  // 菜单项间的距离
  // 菜单项
  static final String[] mainMenu = {"New Game","High Score","Settings","Help","About"};
  // 当前高亮显示的索引号
  static int menuIdx;
  Thread thread;
  // 背景图
  Image bgImage;
  //构造
  public MenuScreen() {
    width = getWidth();
    height = getHeight();
    // 计算菜单开始的高度
    startHeight = (highFont.getHeight() * mainMenu.length) + ((mainMenu.length-1) * spacing);
    startHeight = (height - startHeight) / 2;
    // 默认所选为菜单的第一项
    menuIdx = 0;
    try {
      bgImage = Image.createImage("/res/bg.png");
    } catch (Exception e) {}

    thread = new Thread(this);
    thread.start();
  }
  public void run() {
    while(true) {
      repaint();
    }
  }
public void paint(Graphics g) {
//清屏
    g.setColor(0x00000000);
    g.fillRect(0,0,width,height);
// 背景
    g.drawImage(bgImage,(width - bgImage.getWidth()) / 2, (height - bgImage.getHeight())/2,20);
    for (int i=0; i<mainMenu.length; i++) {
      if (i==menuIdx) {
       //g.setColor(highBGColor);
       //g.fillRect(0,startHeight + (i*highFont.getHeight()) + spacing,width,highFont.getHeight());
        g.setFont(highFont);
        g.setColor(highColor);
        g.drawString(mainMenu,
                     (width - highFont.stringWidth(mainMenu)) / 2,
                      startHeight + (i*highFont.getHeight()) + spacing,
                      20
                     );

      } else {
        g.setFont(lowFont);
        g.setColor(lowColor);
        g.drawString(mainMenu,
                     (width - lowFont.stringWidth(mainMenu)   ) / 2,
                     startHeight + (i*highFont.getHeight()) + spacing,
                     20
                    );
      }
    }
  }

  protected void keyPressed (int code) {
    if (getGameAction(code) == Canvas.UP && menuIdx - 1 >= 0) {
      menuIdx--;
    } else if (getGameAction(code) == Canvas.DOWN && menuIdx + 1 < mainMenu.length) {
      menuIdx++;
    }else if (getGameAction(code) == Canvas.FIRE)
    switch(menuIdx) {
         case NEW_GAME:   System.out.println("Start New Game"); break;
         case HIGH_SCORE: System.out.println("Display High Score"); break;
         case SETTINGS:   System.out.println("Display Settings"); break;
         case HELP:       System.out.println("Display Help"); break;
         case ABOUT:      System.out.println("Display About Info."); break;
       }

  }
}

顺便这里介绍一下J2ME中的字体:
字体的属性由：字体类型，风格和字体大小构成，请注意颜色并不是字体的属性。字体
类型由Form类中的静态常量进行定义，可能的取值:
FACE_MONOSPACE: 等宽字体
FACE_PROPORTIONAL: 比例字体，非常宽
FACE_SYSTEM: 系统字体

字体风格由Font 类中的静态常量进行定义，字体风格是可以多选的，可能的取值为：
STYLE_BOLD : 加粗
STYLE_ITALIC ：斜体
STYLE_PLAIN ：常规
STYLE_UNDERLINED：带下划线字体

字体由Font 类中的静态常量进行定义，可能的取值为：
SIZE_LARGE: 大号字体
SIZE_MEDIUM: 中号字体
SIZE_SMALL: 小号字体

创建字体时并不是通过Font 类的构造方法来创建，而是利用Font类的静态方法
static Font getFont(int face,int style,int size)来创建字体。或者利用
static font getDefauleFont()来创建系统默认字体。
在MIDP v2.0中，为Font类增加了新的一个方法用于创建字体，即 static Font
getFont(int fontSpecifier),参数fontSpecifier的取值范围被定义为Font类
的静态常量，目前只能由俩种取值：
FONT_STATIC_TEXT:静态文本字体,定义了屏幕显示时设备采用的字体
FONT_INPUT_TEXT:输入文体,定义了在用户输入时设备采用的字体
在显示文字时,如果文字过长而超过当前屏幕的宽度,那么多余的部分将无法显示,
所以为了有效地显示文字可以用检测字符或者字符串的宽度的方法,由程序判断每
行输出的字符数,来达到更好的显示效果.

         图片资源乃是游戏的外衣，直接影响一个游戏是否看上去很美。在J2ME游戏开发中，由于受到容量和内存的两重限制，图片使用受到极大的限制。在这种环境中，处理好图片的使用问题就显得更加重要。
 本文从容量和内存两个方面谈谈J2ME游戏图片处理的基本方法。

一 减少图片容量

方法1：将多张png图片集成到一张图片上。
 这是最基本也是最有效的减少png图片容量的办法了。比如你有10张png图片，每张10×15，现在你可以把它集成到一张100×15或者10×150或者X×X的图片上去。这张大png图片的容量比10张png图片的总容量小很多。这是因为省去了9张图片的文件头，文件结束数据块等等，而且合并了调色板（如果10张图片的调色板恰好相同，则省去了9张图片的调色板所占的容量！这是个不小的数字）

方法2：减少图片的颜色数
 减少颜色也算是一个方法？我想说的是什么时候减，谁去减。如果游戏完成后发现容量超出，此时在用优化工具减少颜色，虽然能降低图片容量，但图片效果可能就不让你满意了。所以，在美工作图时就要确定使用的颜色数，手机游戏使用的是象素图，即一个象素一个象素点出来的图像，所以预先规定调色板颜色数量是可以办到的。不过，最终使用优化工具也是有用的，有时候相差一两种颜色，但效果差别并不大，容量却可以变小一些。呵呵，减少颜色确实可以算是一种方法。

方法3：尽可能使用旋转和翻转
 这点不用解释了 

方法4：使用换调色板技术和自定义图片格式
 如果前两种方法还不能满足你对容量的要求，而你的游戏中恰好使用了很多仅颜色不同的怪物，那么可以试试换调色板技术。J2ME规范中规定手机至少可以支持png格式的图片，每张png都带有调色板数据，如果两张图片除了颜色不同而其他（包括颜色数）完全相同，则只要保存一张图片和其他图片的调色板，这相对于保存多张图片来说节省了不少容量。不过这个方法挺麻烦，你得了解png文件格式，然后做一个工具提取出调色板数据和调色板数据块在png文件中的偏移。内存中保存图像仍使用Image,如果要换调色板，则将png文件读入到一个字节数组中，根据调色板数据块在png中的偏移，用新的调色板代替原来的调色板数据，然后用这个字节数组创建出换色后的Image。也许你觉得保存一张png和n份调色板数据的方法有点浪费。至少多保存了1份调色板数据啊！如果直接将图像数据提取出来，在加上n份调色板数据，岂不是更节省容量。但是使用上面的方法，我们还可以用drawImage渲染。如果这样自定义了图片格式，那只有自己写个渲染函数了，这倒还可以，只不过put pixel的速度在某些机器上非常慢。或者自己构造png格式数据,再使用Image.如果你真得决定这么做，我还有个小建议，不要对图像数据进行压缩，zip压缩大多数时候比你写得压缩算法好(参见J2ME Game开发笔记－压缩还是不压缩)。论坛上有位朋友提过使用bmp格式代替png格式，jar中图片容量更小，也是一个道理。

二 减少图片所占内存

1 图片所占内存的计算
 png图片所占用的内存并不对应于图片容量。图片占用的内存的计算为：width*height*bpp。bpp即为系统内置的颜色位数。以Nokia 6600为例，象素格式为565共16位。所以一张100*100的图片占用100*100*(16/8)=20000字节，约为19.5k的内存。象素格式是固定的无法改变，所以只有减少图片的宽和高才能降低其消耗的内存。

2 减少Image对象数量可节约大量内存
 减少Image对象数量不等于减少图片数量。我的意思是说，将一张集成图保存在一个Image对象中，通过setClip的方法从这个Iamge对象中选取你需要的图像渲染。不过这个方法牺牲了一点速度，每帧都从集成图Image中减切图像的速度比无减切的渲染慢。但对于数目不多的渲染，比如精灵，使用这个方法没问题。这个方法还有一个问题就是不能释放集成图中不需要的图片，这就要看你集成的程度了。从图片容量和内存管理的角度综合考虑，我一般使用二次集成的方法。比如有n个精灵,先将各精灵所有的图片集成到一张集成图中，得到n张集成图，然后将这n张集成图再次集成到一张更大的集成图中。这样在jar中只存在一张集成图。使用时，先将大集成图分割载入到n个Image对象中即可。这样各个精灵的图片可以单独管理了。

3 使用旋转和翻转
 只保存一个原始的Image,需要时再旋转或翻转

     1、  高级用户界面

     2、  低级用户界面

     低级用户界面指Canvas类和Graphics类等的使用，以及相应的事件处理，应用与游戏编程以及特殊界面的绘制等。

     3、  记录存储系统

     记录存储系统是手机中支持的用于数据永久保存的技术。因为手机中没有数据文件的概念，所以一般需要保存的数据只能以记录的形式保存。

     4、  声音处理系统

     MIDP1.0不支持声音处理，但是很多手机厂商如Nokia、Siemens等都支持，所以播放声音也是一项需要掌握的技术。该技术使用的API多和手机厂商相关。但是MIDP2.0就提供了通用的支持。

     5、  网络编程

     网络编程指在手机中通过GPRS或者CDMA网络以HTTP协议或者SOCKET的形式连接网络。现在的手机支持HTTP网络编程的占大多数，支持SOCKET的相对很少。所以网络编程暂时也就是使用HTTP协议进行编程。

     6、  多线程

     多线程是J2ME应用中比较核心的技术之一，因为进行网络编程和低级用户界面编程是为了响应迅速，都需要处理成多线程。所以也必须熟练掌握。

     7、  短信息编程

     很多手机都提供了用于发送短信息的API，如NOKIA、SIEMENS、SAMSUNG等，所以在J2ME中发送短信息也是一个比较常用的技术。

     8、  其他

     当然根据厂商的不同还提供了其他的一些技术，如Siemens的API中支持文件，Nokia的API支持读取系统通讯录等等。

任何动画的最基本的前提，是要在足够快的时间内显示和更换一张张的图片，让人的眼睛看到动的画面效果。图片必须按照顺序画出来。从一张图片到下一张图片之间的变化越小，效果会越好。

首先要做的，是使用你的图片处理软件（比如ps或者firework）创建一系列相同大小的图片来组成动画。每张图片代表动画一帧。

你需要制作一定数量的祯－－越多的帧会让你的动画看上去越平滑。制作好的图片一定要保存成PNG(Portable Network Graphics) 格式，MIDP唯一支持的图片格式；（有两个办法让你刚做好的图片在MIDlet上变成动画。第一，把图片都放到一个web服务器上，让MIDlet下载他们，MIDP内置的HTTP支持。第二个办法更简单，把图片用MIDlet打包成jar文件。如果你使用的是J2ME开发工具，把PNG文件放在你的项目文件里面就可以了。

动画的过程其实更像帐本记录：显示当前帧，然后适当地更换到下一帧。那么使用一个类来完成这个工作应该是很恰当的，那好，我们就先定义一个AnimatedImage类：

import java.util.*;
import javax.microedition.lcdui.*;
// 定义了一个动画，该动画其实只是一系列相同大小的图片
// 轮流显示，然后模拟出的动画
public class AnimatedImage extends TimerTask {;
private Canvas canvas;
private Image[] images;
private int[][] clipList;
private int current;
private int x;
private int y;
private int w;
private int h;

// Construct an animation with no canvas.

public AnimatedImage( Image[] images ){;
this( null, images, null );
};

// Construct an animation with a null clip list.

public AnimatedImage( Canvas canvas, Image[]
images ){; this( canvas, images, null );
};

// Construct an animation. The canvas can be null,
// but if not null then a repaint will be triggered
// on it each time the image changes due to a timer
// event. If a clip list is specified, the image is
// drawn multiple times, each time with a different
// clip rectangle, to simulate transparent parts.

public AnimatedImage( Canvas canvas, Image[] images,
int[][] clipList ){;
this.canvas = canvas;
this.images = images;
this.clipList = clipList;

if( images != null && clipList != null ){;
if( clipList.length < images.length ){;
throw new IllegalArgumentException();
};
};

if( images != null && images.length > 0 ){;
w = images[0].getWidth();
h = images[0].getHeight();
};
};

// Move to the next frame, wrapping if necessary.

public void advance( boolean repaint ){;
if( ++current >= images.length ){;
current = 0;
};

if( repaint && canvas != null && canvas.isShown()
){;
canvas.repaint( x, y, w, h );
canvas.serviceRepaints();
};
};

// Draw the current image in the animation. If
// no clip list, just a simple copy, otherwise
// set the clipping rectangle accordingly and
// draw the image multiple times.

public void draw( Graphics g ){;
if( w == 0 || h == 0 ) return;

int which = current;

if( clipList == null || clipList[which] == null
){;
g.drawImage( images[which], x, y,
g.TOP | g.LEFT );
}; else {;
int cx = g.getClipX();
int cy = g.getClipY();
int cw = g.getClipWidth();
int ch = g.getClipHeight();

int[] list = clipList[which];

for( int i = 0; i + 3 <= list.length; i +=
4 ){;
g.setClip( x + list[0], y + list[1],
list[2], list[3] );
g.drawImage( images[which], x, y,
g.TOP | g.LEFT );
};

g.setClip( cx, cy, cw, ch );
};
};

// Moves the animation's top left corner.

public void move( int x, int y ){;
this.x = x;
this.y = y;
};

// Invoked by the timer. Advances to the next frame
// and causes a repaint if a canvas is specified.

public void run(){;
if( w == 0 || h == 0 ) return;

advance( true );
};
};

这是以白色为幕布做出来的图片----锯齿非常明显。

将完成的原画背静改为兰色------是这样样子滴！

将上图减小尺寸过后------就是这个样子滴！

此时再用你所能想到的任何方法，在不明显失真的前提下进行颜色压缩，最后把兰色去掉，就得到成品啦。哈哈啊。

用另外一个女生的图片做的图
同样的方法，可以取得同样良好的结果。

反复进行不同背静的测试，
发现锯齿问题解决得很好，兰色的背静幕布在抠图过后能与其他颜色很好的融合。

前面的朋友说了动画的制作,一个动画是由很多帧组在的.,您说的方法把一帧帧的动画做成一幅幅的图象,再一幅幅地载入,这样做的效率不高.应该把各幅员的动画放在一起,做成一幅大的图,加载一幅大图比加载多幅小图效率要高,一幅大图也比多幅小图容易管理得多.那么怎样做呢?

做法和前面朋友说的差不多,关键是这个方法:
drawImage(Image img,dx1,dy1,dx2,dy2,sx1,sy1,sx1,sy1,this)
其中Image img是来源图象,
    dx1是目的区域的===左上===顶点的===X====坐标;

    dy1是目的区域的===左上===顶点的===Y====坐标;

    dx2是目的区域的===右下===顶点的===X====坐标;

    dy2是目的区域的===右下===顶点的===Y====坐标;

    sx1是来源区域的===左上===顶点的===X====坐标;

    sy1是来源区域的===左上===顶点的===Y====坐标;

    sx2是来源区域的===右下===顶点的===X====坐标;

    sy2是来源区域的===右下===顶点的===Y====坐标.
================================================================
下面是一个动画的程序代码.
import java.awt.*;
import java.applet.*;
public class Seriallmage4 extends Applet implements Runnable
{
  int SPF;                       //用来表示线程暂停的时间
  int sx,sy;
/******************************************************************
sx,sy用来表示来源区域的左上顶点.因为每一帧我们都做成了长是80宽87的图,再把它们放在一起做成一幅大的图,
所以来源区域的右下顶点的坐标等于左上顶点坐标加上长和高.
式子为:sx+80;sy+87
******************************************************************/                     
  Image Animation;              //来源图象
  MediaTracker MT;              //图像追踪器,用来检查图像是否完全加载
  Thread newThread;             //新的线程.
  Image OffScreen;              //后台图像;
  Graphics drawOffScreen;       //绘制后台图像的实体(实例).
//======================init()函数===========================
  public void init()
  {
     SPF=100;                   //线程暂停的时间是100豪秒,
     MT=new MediaTracker(this); //实体化图像追踪器.
     Animation=getImage(getDocumentBase(),"lunisEx.gif");//加载图像.
//======================//追踪图像=============================
     MT.addImage(Animation,0);  
     try
     {
       showStatus("图象加载中....");   //在状态栏中显示信息
       MT.waitForAll();                //等待加载
     }
     catch(InterruptedException E){}
//============================================================
     OffScreen=createImage(300,300);  //建立后台画面的实体
     drawOffScreen=OffScreen.getGraphics();  //取得后台画面的绘制类
  }
//===========================================================
  public void start()                //start函数
  {
     newThread=new Thread(this);     //建立线程
     newThread.start();              //启动线程
  }
  public void stop()                 //stop函数
  {
     newThread=null;                 //线程设为null
  }
//==========================================================
  public void paint(Graphics g)
  {
     drawOffScreen.setColor(Color.green);    //设置后台画面的背景色,
     drawOffScreen.fillRect(0,0,300,300);    //画一次背景,作用是清除后台画面,如果背景是一幅画
//则要用这幅图来画.
     drawOffScreen.drawImage(Animation,20,20,250,250,sx,sy,sx+80,sy+87,this);//在后台画面绘制
//的图像,
     g.drawImage(OffScreen,0,0,300,300,this);//把后台画面画到前台画面
  }
  public void update(Graphics g)
  {
     paint(g);                              
  }
//====================新动画循环在此========================50
   public void run()                       
   {
      while(newThread !=null)               //如果线程不等于null
      {
        repaint();                         // 重画一次.
        try
        {
           Thread.sleep(SPF);              //让线程暂停
           sx+=80;                         //画了一次后,改变来源区域,使其到下一帧.
           if(sx==800)                     //我的图像是一幅800*170的,有两行,每行十帧,如果sx走到了
//800就说明播放完第一行了,
           {
              sy+=85;                      //播放完第一行后,改变来源区域的左上顶点使其跑到第二行.
              sx=0;
              if(sy==170)                  //如果播放完第二行后,又让它回到第一行,
              {
                 sy=0;
              }
           }
        }
        catch(InterruptedException E){}
      }
    }

}
动画每秒播放多少帧好呢?
电影的是每秒24帧,这样的速度不仅能产生视觉停留,而且让人感觉到画面非常流畅.那么是不是我们做游戏也要用这个速度呢?答案是否定的,实际上每秒播放10帧就足已产生视觉停留,如果设置高了会消耗更多的资源.至命的是,有一些手机连每秒10帖都做不到.

一、序言

　　昨天在网上闲逛，发现一篇讲解用delphi实现华容道游戏的文章，颇受启发．于是，产生了将华容道游戏移植到手机中去的冲动．现在手机游戏琳琅满目，不一而足，华容道的实现版本也很多．正巧不久前笔者对J2ME下了一番功夫，正想借这个机会小试牛刀。选用J2ME的原因还有一个就是目前Java开发大行其到，无线增殖业务迅猛发展，J2ME的应用日渐活跃起来，也希望我的这篇文章能够为J2ME知识的普及和开发团队的壮大推波助澜。由于长期受ISO规范的影响，这次小试牛刀我也打算遵照软件工程的要求，并采取瀑布式的开发模式来规划项目，也希望借此机会向各位没有机会参与正式项目开发的读者介绍一下软件开发的流程。

　　这里我们先定义项目组的人员体制(其实只有我一个人)：技术调研、需求分析、概要设计、详细设计、编码、测试均有笔者一人担任；美工这里我找了个捷径，盗用网上现成的图片，然后用ACDSee把它由BMP转换成PNG格式(我出于讲座的目的，未做商业应用，应该不算侵权吧)；至于发布工作，由于缺少OTA服务器，此项工作不做(但是我会介绍这步如何做)。

　　接下来，我们规划一下项目实现的时间表，以我个人经验，设想如下：技术调研用2天(这部分解决项目的可行性和重大技术问题，时间会长一些)，需求分析用半天(毕竟有现成的东东可以参照，只要理清思路就行了，况且还有很多以前用过的设计模式和写好的代码)，概要设计再用半天(有了需求，概要只不够是照方抓药)，详细设计要用2天(这一步要把所有的问题想清楚，还要尽可能的准确描述出来)，编码用2天(其实1天就够了，技术已经不是问题，多计划出一天来应付突发事件)，测试用2天(测试应该至少占全部项目的四分之一，不过这个项目只是一个Demo，也太简单了)，发布也要用上半天(尽管我们不去实际发布它，但是还要花点时间搞清楚应该如何做)，最后就是项目总结和开庆功会(时间待定)。

　　二.利其器

　　“公欲善其事，必先利其器”，做项目之前第一步是前期调研．我们要做的华容道这个东东随处可见，我们要调研的是两个方面：

　　1、游戏的内容：游戏本身很简单，就是有几个格子，曹操占据其中一个较大的格子，然后被几个格子包围，这些格子形状不一定相同，但是挡住了曹操移动的方向．游戏者需要挪动这些格子最终把曹操移动到一个指定的位置才算是过关．更具体的分析我们放在后面需求分析和概要设计中讨论。

　　2、技术储备：谈到技术，这里简单介绍一下J2ME.Java有三个版本，分别是J2ME（微型版）.J2SE（标准版）.J2EE（企业版）．J2ME是一个标准，采用３层结构设计．最低层是配置层（Configuration）也就是设备层，其上是简表层（Profile）,再上是应用层（Application）.MIDP就是移动信息设备简表，目前主流手机支持MIDP1.0，最新的是MIDP2.0,它比前一个版本增加了对游戏的支持，在javax.microedition.lcdui.game包中提供了一些类来处理游戏中的技术，比如我们后面会用到的Sprite类，它是用来翻转图片的.权衡再三，笔者决定使用MIDP2.0来做开发．首先需要安装一个J2ME的模拟器，我们就用Sun公司的WTK2.0，我觉得Sun的东西最权威．当然你也可以使用Nokia.Siemens或是Motolora等其他模拟器，但是他们的JDK不尽相同，写出来的程序移植是比较麻烦的．Sun公司的WTK2.0可以到＜A href="http://here/下"＞http://here/下＜/A＞载，当然要想成功下载的前提是你要先注册成为Sun的会员（其实这样对你是有好处的）．当下来之后就是按照提示一步一步的安装．安装好了之后，我们用一个"Hello World"程序开始你的J2ME之旅．我们启动WTK2.0工具集中的KToolBar，然后点击New Project按钮，在弹出的输入框中输入Project Name为HelloWorld,MIDlet Class Name为Hello,然后点击Create Project，开始生成项目，工具会弹出MIDP配置简表，这里接受生成的默认值（以后还可以修改）点击OK，工具提示我们把写好的Java源程序放到[WTK_HOME]\apps\HelloWorld\src目录之下．我们编辑如下代码，并保存在上述目录之下，文件名为Hello.java。

import javax.microedition.midlet.*; import javax.microedition.lcdui.*; public class Hello extends MIDlet { private Display display; public Hello(){ display =Display.getDisplay(this); } public void startApp(){ TextBox t = new TextBox("Hello","Hello",256,0); display.setCurrent(t); } public void pauseApp(){ } public void destroyApp(boolean unconditional){ } }

　　保存好了之后，点击Build按钮，工具会为你编译程序，如无意外再点击Run按钮，会弹出一个手机界面，剩下的就不用我教了吧（用鼠标对手机按键一顿狂点）。呵呵，你的第一个J2ME程序已经OK了.什么？你还一点都没懂呢（真是厉害，不懂都能写出J2ME程序来，果然是高手）．我这里主要是介绍WTK2.0工具的使用，程序并不是目的，不懂的话后面还会有详细的解说，这里只是带你上路．什么？你不懂Java！那也没有关系，后面我再讲得细一点。

　　跳过J2ME，我们先来讲点游戏的理论．具体到华容道这个游戏，主要有三个方面，贴图．游戏操作．逻辑判断．这里讲讲贴图，其他两方面放在概要设计和详细设计里讲．所谓的贴图，其实就是画图，就是在要显示图形的位置上输出一副图片，（要是牵扯到动画就要麻烦一些，可以使用TimerTask.Thread或Rannable之类的技术)，这副图片可以是事先准备好的也可以是临时处理的．在J2ME中有一个Image类,专门用于管理图片，它有createImage()方法，可以直接读取图片文件（J2ME只支持PNG格式的图片），也可以截取已有的图片的一部分（这样我们可以把很多图片放在一起，然后一张一张的截下来，好处是节省存储空间和文件读取时间，对于手机这两者都是性能的瓶颈）．J2ME还有一个Graphics类，专门用于绘图，它有drawImage()方法，可以把一副图片在指定的位置上显示出来，它还有drawRect()方法和setColor()方法，这两个方法在后面我们进行游戏操作时就会用到，这里先交代一下．有了图片和绘图的方法，还需要知道把图画到谁身上，J2ME提供了一个Canvas类，字面意思就是画布，它有一个paint()方法用于刷新页面，还有一个repaint()方法用于调用paint()方法．听着有些糊涂是吧，不要紧，我来结合具体程序讲解一下．为了今后编程的方便，我们创建两个类Images和Draw,Images用于保存一些常量值和图片，Draw主要是用于画图，这两个类的源代码如下。

　　Images类的源代码如下：

package huarongroad; import javax.microedition.lcdui.*; import javax.microedition.lcdui.game.*; public class Images {//保存常量 //绘图位置常量 public static final int UNIT = 32;//方块的单位长度 public static final int LEFT = 10;//画图的左边界顶点 public static final int TOP = 9;//画图的上边界顶点 //地图位置常量 public static final int WIDTH = 4;//地图的宽度 public static final int HEIGHT = 5;//地图的高度 //地图标记常量 public static final byte CAOCAO = (byte) 'a'; ＜A href="file://曹"＞file://曹＜/A＞操的地图标记 public static final byte MACHAO = (byte) 'b';//马超的地图标记 public static final byte HUANGZHONG = (byte) 'c';//黄忠的地图标记 public static final byte GUANYU = (byte) 'd';//关羽的地图标记 public static final byte ZHANGFEI = (byte) 'e';//张飞的地图标记 public static final byte ZHAOYUN = (byte) 'f';//赵云的地图标记 public static final byte ZU = (byte) 'g';//卒的地图标记 public static final byte BLANK = (byte) 'h';//空白的地图标记 public static final byte CURSOR = (byte) 'i';//光标的地图标记 //地图组合标记常量 public static final byte DLEFT = (byte) '1'; ＜A href="file://组"＞file://组＜/A＞合图形左边标记 public static final byte DUP = (byte) '2'; ＜A href="file://组"＞file://组＜/A＞合图形上边标记 public static final byte DLEFTUP = (byte) '3'; ＜A href="file://组"＞file://组＜/A＞合图形左上标记 //图片常量 public static Image image_base;//基本图片 public static Image image_Zhaoyun;//赵云的图片 public static Image image_Caocao;//曹操的图片 public static Image image_Huangzhong;//黄忠的图片 public static Image image_Machao;//马超的图片 public static Image image_Guanyu;//关羽的图片 public static Image image_Zhangfei;//张飞的图片 public static Image image_Zu;//卒的图片 public static Image image_Blank;//空白的图片 public static Image image_Frame;//游戏框架的图片 public Images() {//构造函数 } public static boolean init() {//初始化游戏中用到的图片 try { image_base = Image.createImage("/huarongroad/BITBACK.png"); image_Frame = Image.createImage(image_base, 126, 0, 145, 177, Sprite.TRANS_NONE); //Sprite类是用来翻转图片的，是MIDP2.0新新增加的支持游戏的特性 image_Zhaoyun = Image.createImage(image_base, 0, 0, UNIT, 2 * UNIT, Sprite.TRANS_NONE); image_Caocao = Image.createImage(image_base, UNIT, 0, 2 * UNIT, 2 * UNIT, Sprite.TRANS_NONE); image_Huangzhong = Image.createImage(image_base, 3 * UNIT, 0, UNIT, 2 * UNIT, Sprite.TRANS_NONE); image_Machao = Image.createImage(image_base, 0, 2 * UNIT, UNIT, 2 * UNIT, Sprite.TRANS_NONE); image_Guanyu = Image.createImage(image_base, UNIT, 2 * UNIT, 2 * UNIT, UNIT, Sprite.TRANS_NONE); image_Zhangfei = Image.createImage(image_base, 3 * UNIT, 2 * UNIT, UNIT, 2 * UNIT, Sprite.TRANS_NONE); image_Zu = Image.createImage(image_base, 0, 4 * UNIT, UNIT, UNIT, Sprite.TRANS_NONE); image_Blank = Image.createImage(image_base, 1 * UNIT, 4 * UNIT,UNIT, UNIT, Sprite.TRANS_NONE); return true; }catch (Exception ex) { return false; } } }

　　Draw类的源代码如下：

package huarongroad; import javax.microedition.lcdui.*; public class Draw { //绘制游戏中的图片 public Draw(Canvas canvas) {//构造函数 } public static boolean paint(Graphics g, byte img, int x, int y) { //在地图的x,y点绘制img指定的图片 try { paint(g, img, x, y, Images.UNIT);//把地图x,y点转化成画布的绝对坐标，绘图 return true; } catch (Exception ex) { return false; } } public static boolean paint(Graphics g, byte img, int x, int y, int unit) { try { switch (img) { case Images.CAOCAO://画曹操 //变成绝对坐标，并做调整 g.drawImage(Images.image_Caocao, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.GUANYU://画关羽 g.drawImage(Images.image_Guanyu, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.HUANGZHONG://画黄忠 g.drawImage(Images.image_Huangzhong, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.MACHAO://画马超 g.drawImage(Images.image_Machao, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.ZHANGFEI://画张飞 g.drawImage(Images.image_Zhangfei, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.ZHAOYUN://画赵云 g.drawImage(Images.image_Zhaoyun, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.ZU://画卒 g.drawImage(Images.image_Zu, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.BLANK://画空白 g.drawImage(Images.image_Blank, Images.LEFT + x * unit, Images.TOP + y * unit, Graphics.TOP | Graphics.LEFT); break; case Images.CURSOR://画光标 g.drawRect(Images.LEFT + x * unit, Images.TOP + y * unit,Images.UNIT,Images.UNIT); break; } return true; }catch (Exception ex) { return false; } } }

　　其中Images类存的是绘图位置常量（也就是在画图时每个格子的长度和相对坐标原点位置要进行的调整）、地图位置常量（地图的长、宽），地图标记常量（人物对应的记号），地图组合标记常量（后面会细说），图片常量（存放人物的图片）；Draw类主要负责在制定的位置画出人物图片。下面我来说说Images类中的地图标记常量和地图组合标记常量。为了能够灵活的安排各个关面的布局，我们决定把游戏布局的信息存储在外部文件中，然后程序启动后把它读进来。这样我们制定了一套存储图片的代码，这就是地图标记常量，如上面Images类中定义的Caocao(曹操)用a字符来表示，当程序读到a字符时就能将它转化成曹操对应的图片，并在读到a字符的位置上进行显示。但是从实际观察中我们发现所有的图片并不是统一大小的，有的占4个格子，有的占2个格子，还有的占1个格子，而且即便同是占两个格子的图片还有横、竖之分。有鉴于此，我们引入了地图组合标记常量，就是说在遇到占有多个格子的时候，值1(也就是Images.LEFT)表示它的左边是一个真正的地图标记，值2(也就是Images.UP)表示它的上边是一个真正的地图标记，值1(也就是Images.LEFTUP)表示它的左上边是一个真正的地图标记。地图组合标记常量其实就是用来占位置的，与实际显示无关，当后面我们将到移动时还会再来分析组合标记的使用。

　　Draw类主要是用来在画布上画出图形，它有两个paint方法，这是很常见的函数重载。但是程序中实际上只用到了4个参数的paint方法，它直接获得要画图片的相对坐标位置信息，然后调用5个参数的paint方法。5个参数的paint方法将相对坐标位置信息转换成绝对位置，并实际调用Graphics.drawImage()方法，将Images中的图片画了出来。这种实现方法的好处是灵活和便于扩展，但你需要画图的位置并不能够对应到格子中的相对坐标位置时，你就可以直接调用5个参数的paint方法，而不必再去修改这各类；但你添加新的图片时，只要在Images中增加对应的常量，然后向Draw中5个参数的paint方法添加一条处理就可以了。
写到这里，两天的时间刚好用完。

　　三、需求分析

　　这部分叫做需求分析，听起来挺吓人的，其实就是搞清楚我们要做什么，做成什么样，那些不做。下面我引领着大家共同来完成这一步骤。首先，我们要做一个华容道的游戏，华容道的故事这里不再赘述了，但其中的人物在这里限定一下，如上面Images类里的定义，我们这个版本只提供曹操(Caocao)、关羽(Guanyu)、张飞(Zhangfei)、赵云(Zhaoyun)、黄忠(Huangzhong)、马超(Machao)和卒(Zu)。我们这里也限定一下游戏的操作方法：首先要通过方向键选择一个要移动的区域(就是一张图片)，被选择的区域用黑色方框框住；选好后按Fire键(就是确定键)将这块区域选中，被选中的区域用绿色方框框住；然后选择要移动到的区域，此时用红色方框框住被选择的区域；选好要移动到的区域之后按Fire键将要移动的区域(图片)移到要移动到的区域，并去掉绿色和红色的方框。这里需要强调的概念有选择的区域、选中的区域、要移动的区域和要移动到的区域，这四个概念请读者注意区分，当然也应当把这一部分记入数据字典之中。为了使文章的重点突出(介绍如何制作一个J2ME的收集游戏)，我们这里限定一些与本主题无关的内容暂不去实现：过关之后的动画(实现时要用到TimerTask或Thread类，后续的系列文章中我会详细介绍动画方面的知识)、关面之间的切换(其实很简单，当完成任务之后重新再做一边)、暂停和保存等操作(这部分的内容介绍的资料很多，我也写不出什么新的东东来，难免抄袭，故此免掉)。

　　需求分析基本完成，离下午还有一段时间，马上动手用ACDSee把从网上找来的BMP文件，调整其大小为271*177(我的这个图片是两个部分合在一起，所以比手机实际屏幕大了)，另存为PNG格式。半天时间刚刚好，不但搞清楚了要做的东东，还把要用的图片准备好了。

　　四、概要设计

　　概要设计是从需求分析过渡到详细设计的桥梁和纽带，这一部分中我们确定项目的实现方法和模块的划分。我们决定将整个项目分成五个部分，分别是前面介绍的Images、Draw，还有Map和Displayable1和MIDlet1。Images和Draw类功能简单、结构固定，因此很多项目我们都使用这两各类，这里直接拿来改改就能用了，前面已经介绍过这里不再赘述。Map类是用来从外部文件读入地图，然后保存在一个数组之中，这部分的内容是我们在本阶段讨论的重点。Displayable1是一个继承了Canvas类的画布，它用来处理程序的主要控制逻辑和一部分控制逻辑所需的辅助函数，主要函数应该包括用来绘图的paint()函数、用来控制操作的keyPressed()函数、用来控制选择区域的setRange()函数、用来控制选择要移动到区域的setMoveRange()函数、用来移动选中区域的Move()函数和判断是否完成任务的win()函数，更具体的分析，我们放到详细设计中去细化。MIDlet1实际上就是一个控制整个J2ME应用的控制程序，其实也没有什么可特别的，它和我们前面介绍的"Hello World"程序大同小异，这里就不展开来说了，后面会贴出它的全部代码。

　　Map类主要应该有一个Grid[][]的二维数组，用来存放华容道的地图，还应该有一个read_map()函数用来从外部文件读取地图内容填充Grid数据结构，再就是要有一个draw_map()函数用来把Grid数据结构中的地图内容转换成图片显示出来(当然要调用Draw类的paint方法)。说到读取外部文件，笔者知道有两种方法：一种是传统的定义一个InputStream对象，然后用getClass().getResourceAsStream()方法取得输入流，然后再从输入流中取得外部文件的内容，例如

InputStream is = getClass().getResourceAsStream("/filename"); if (is != null) { byte a = (byte) is.read(); }

　　这里请注意文件名中的根路径是相对于便以后的class文件放置的位置，而不是源文件(java)。第二种方法是使用onnector.openInputStream方法，然后打开的协议是Resource，但是这种方法笔者反复尝试都没能调通，报告的错误是缺少Resource协议，估计第二种方法用到J2ME的某些扩展类包，此处不再深究。由于以前已经做过一些类似华容道这样的地图，这里直接给出Map类的代码，后面就不再详细解释Map类了，以便于我们可以集中精力处理Displayable1中的逻辑。Map类的代码如下：

package huarongroad; import java.io.InputStream; import javax.microedition.lcdui.*; public class Map { //处理游戏的地图，负责从外部文件加载地图数据，存放地图数据，并按照地图数据绘制地图 public byte Grid[][];//存放地图数据 public Map() {//构造函数，负责初始化地图数据的存储结构 this.Grid = new byte[Images.HEIGHT][Images.WIDTH]; //用二维数组存放地图数据，注意第一维是竖直坐标，第二维是水平坐标 } public int[] read_map(int i) { ＜A href="file://从"＞file://从＜/A＞外部文件加载地图数据，并存放在存储结构中，返回值是光标点的位置 //参数是加载地图文件的等级 int[] a = new int[2];//光标点的位置，0是水平位置，1是竖直位置 try { InputStream is = getClass().getResourceAsStream( "/huarongroad/level".concat(String.valueOf(i))); if (is != null) { for (int k = 0; k ＜ Images.HEIGHT; k++) { for (int j = 0; j ＜ Images.WIDTH; j++) { this.Grid[k][j] = (byte) is.read(); if ( this.Grid[k][j] == Images.CURSOR ) { //判断出光标所在位置 a[0] = j;//光标水平位置 a[1] = k;//光标竖直位置 this.Grid[k][j] = Images.BLANK;//将光标位置设成空白背景 } } is.read();//读取回车（13）,忽略掉 is.read();//读取换行（10）,忽略掉 } is.close(); }else { //读取文件失败 a[0] = -1; a[1] = -1; } }catch (Exception ex) { //打开文件失败 a[0] = -1; a[1] = -1; } return a; } public boolean draw_map(Graphics g) { //调用Draw类的静态方法，绘制地图 try { for (int i = 0; i ＜ Images.HEIGHT; i++) { for (int j = 0; j ＜ Images.WIDTH; j++) { Draw.paint(g, this.Grid[i][j], j, i);//绘制地图 } } return true; }catch (Exception ex) { return false; } } }

　　对于像华容道这样的小型地图可以直接用手工来绘制地图的内容，比如：

fa1c
2232
bd1e
2gg2
gihg

　　但是，如果遇到像坦克大战或超级玛莉那样的地图，就必须另外开发一个地图编辑器了(我会在后续的文章中介绍用vb来开发一个地图编辑器)。

　　五、详细设计

　　详细设计是程序开发过程中至关重要的一个环节，好在我们在前面的各个阶段中已经搭建好了项目所需的一些工具，现在这个阶段中我们只需集中精力设计好Displayable1中的逻辑。(两天的时间当然不只干这点活，还要把其他几个类的设计修改一下)

　　Displayable1这个类负责处理程序的控制逻辑。首先，它需要有表示当前关面的变量level、表示当前光标位置的变量loc、表示要移动区域的变量SelectArea、表示要移动到的区域的变量MoveArea、表示是否已有区域被选中而准备移动的变量Selected和Map类的实例MyMap。然后，我们根据用户按不同的键来处理不同的消息，我们要实现keyPressed()函数，在函数中我们处理按键的上下左右和选中(Fire)，这里的处理需要我展开来讲一讲，后面我很快会把这一部分详细展开。

　　接下来，是实现paint()函数，我们打算在这一部分中反复的重画背景、地图和选择区域，这个函数必须处理好区域被选中之后的画笔颜色的切换，具体讲就是在没有选中任何区域时要用黑色画笔，当选重要移动的区域时使用绿色画笔，当选择要移动到的区域时改用红色画笔(当然附加一张流程图是必不可少的)。

　　再下面要实现的setRange()函数和setMoveRange()函数，这两个函数用来设置要移动的区域和要移动到的区域，我的思路就是利用前面在Images类中介绍过的地图组合标记常量，当移动到地图组合标记常量时，根据该点地图中的值做逆向变换找到相应的地图标记常量，然后设置相应的loc、SelectArea和MoveArea,其中setMoveRange()函数还用到了一个辅助函数isInRange(),isInRange()函数是用来判断给定的点是否在已选中的要移动的区域之内,如果isInRange()的返回值是假并且该点处的值不是空白就表明要移动到的区域侵犯了其他以被占用的区域。有了setRange()和setMoveRange()函数，Move()函数就水到渠成了,Move()函数将要移动的区域移动到要移动到的区域,在移动过程中分为三步进行:

　　第一.复制要移动的区域；

　　第二.将复制出的要移动区域复制到要移动到的区域(这两步分开进行的目的是防止在复制过程中覆盖掉要移动的区域)；

　　第三.用isInRange2()判断给定的点是否在要移动到的区域内,将不在要移动到的区域内的点设置成空白。

　　下面我们详细的分析一下keyPressed()函数的实现方法:首先,keyPressed()函数要处理按键的上下左右和选中(Fire),在处理时需要用Canvas类的getGameAction函数来将按键的键值转换成游戏的方向,这样可以提高游戏的兼容性(因为不同的J2ME实现,其方向键的键值不一定是相同的)。

　　接下来,分别处理四个方向和选中.当按下向上时,先判断是否已经选定了要移动的区域(即this.selected是否为真),如果没有选中要移动区域则让光标向上移动一格,然后调用setRange()函数设置选择要移动的区域,再调用repaint()函数刷新屏幕,否则如果已经选中了要移动的区域,就让光标向上移动一格,然后调用setMoveRange()函数判断是否能够向上移动已选中的区域,如果能移动就调用repaint()函数刷新屏幕,如果不能移动就让光标向下退回到原来的位置。

　　当按下向下时,先判断是否已经选定了要移动的区域,如果没有选中要移动的区域则判断当前所处的区域是否为两个格高,如果是两个格高则向下移动两格,如果是一个格高则向下移动一格,接着再调用setRange()函数设置选择要移动的区域,而后调用repaint()函数刷新屏幕,否则如果已经选中了要移动的区域,就让光标向下移动一格,然后调用setMoveRange()函数判断是否能够向下移动已选中的区域,如果能移动就调用repaint()函数刷新屏幕,如果不能移动就让光标向上退回到原来的位置.按下向左时情况完全类似向上的情况,按下向右时情况完全类似向下的情况,因此这里不再赘述,详细情况请参见程序的源代码。

　　当按下选中键时,先判断是否已经选中了要移动的区域,如果已经选中了要移动的区域就调用Move()函数完成由要移动的区域到要移动到的区域的移动过程,接着调用repaint()函数刷新屏幕,然后将已选择标记置成false,继续调用win()函数判断是否完成了任务,否则如果还没有选定要移动的区域则再判断当前选中区域是否为空白,如果不是空白就将选中标记置成true,然后刷新屏幕.这里介绍一个技巧,在开发程序遇到复杂的逻辑的时候,可以构造一格打印函数来将所关心的数据结构打印出来以利调试,这里我们就构造一个PrintGrid()函数,这个函数纯粹是为了调试之用,效果这得不错.至此我们完成了编码前的全部工作。

　　六.编码

　　整个项目共有五个类,有四个类的代码前面已经介绍过了,而且是在其他项目中使用过的相对成熟的代码.现在只需全力去实现Displayable1类.Displayable1类的代码如下:

package huarongroad; import javax.microedition.lcdui.*; public class Displayable1 extends Canvas implements CommandListener { private int[] loc = new int[2]; ＜A href="file://光"＞file://光＜/A＞标的当前位置，0是水平位置，1是竖直位置 private int[] SelectArea = new int[4];//被选定的区域，即要移动的区域 private int[] MoveArea = new int[4];//要移动到的区域 private Map MyMap = new Map();//地图类 private boolean selected;//是否已经选中要移动区域的标志 private int level;//但前的关面 public Displayable1() {//构造函数 try { jbInit();//JBuilder定义的初始化函数 }catch (Exception e) { e.printStackTrace(); } } private void Init_game(){ //初始化游戏，读取地图，设置选择区域，清空要移动到的区域 this.loc = MyMap.read_map(this.level);//读取地图文件，并返回光标的初始位置 //0为水平位置，1为竖直位置 this.SelectArea[0] = this.loc[0];//初始化选中的区域 this.SelectArea[1] = this.loc[1]; this.SelectArea[2] = 1; this.SelectArea[3] = 1; this.MoveArea[0] = -1;//初始化要移动到的区域 this.MoveArea[1] = -1; this.MoveArea[2] = 0; this.MoveArea[3] = 0; } private void jbInit() throws Exception {//JBuilder定义的初始化函数 ＜A href="file://初"＞file://初＜/A＞始化实例变量 this.selected = false;//设置没有被选中的要移动区域 this.level = 1; Images.init();//初始化图片常量 Init_game();//初始化游戏，读取地图，设置选择区域，清空要移动到的区域 setCommandListener(this);//添加命令监听，这是Displayable的实例方法 addCommand(new Command("Exit", Command.EXIT, 1));//添加“退出”按钮 } public void commandAction(Command command, Displayable displayable) { //命令处理函数 if (command.getCommandType() == Command.EXIT) {//处理“退出” MIDlet1.quitApp(); } } protected void paint(Graphics g) { //画图函数，用于绘制用户画面，即显示图片，勾画选中区域和要移动到的区域 try { g.drawImage(Images.image_Frame, 0, 0, Graphics.TOP | Graphics.LEFT);//画背景 MyMap.draw_map(g);//按照地图内容画图 if ( this.selected ) g.setColor(0,255,0);//如果被选中，改用绿色画出被选中的区域 g.drawRect(this.SelectArea[0] * Images.UNIT + Images.LEFT, this.SelectArea[1] * Images.UNIT + Images.TOP, this.SelectArea[2] * Images.UNIT, this.SelectArea[3] * Images.UNIT);//画出选择区域， ＜A href="file://如"＞file://如＜/A＞果被选中，就用绿色 ＜A href="file://否"＞file://否＜/A＞则，使用黑色 g.setColor(255,255,255);//恢复画笔颜色 if (this.selected) {//已经选中了要移动的区域 g.setColor(255, 0, 255);//改用红色 g.drawRect(this.MoveArea[0] * Images.UNIT + Images.LEFT, this.MoveArea[1] * Images.UNIT + Images.TOP, this.MoveArea[2] * Images.UNIT, this.MoveArea[3] * Images.UNIT);//画出要移动到的区域 g.setColor(255, 255, 255);//恢复画笔颜色 } }catch (Exception ex) { } System.out.println(Runtime.getRuntime().freeMemory()); System.out.println(Runtime.getRuntime().totalMemory()); } private void setRange() { //设置移动后能够选中的区域 //调整当前光标位置到地图的主位置，即记录人物信息的位置 if (this.MyMap.Grid[this.loc[1]][this.loc[0]] == Images.DLEFT) { this.loc[0] -= 1;//向左调 }else if (this.MyMap.Grid[this.loc[1]][this.loc[0]] == Images.DUP) { this.loc[1] -= 1;//向上调 }else if (this.MyMap.Grid[this.loc[1]][this.loc[0]] == Images.DLEFTUP) { this.loc[0] -= 1;//向左调 this.loc[1] -= 1;//向上调 } this.SelectArea[0] = this.loc[0];//设置光标的水平位置 this.SelectArea[1] = this.loc[1];//设置光标的竖直位置 //设置光标的宽度 if (this.loc[0] + 1 ＜ Images.WIDTH) { this.SelectArea[2] = this.MyMap.Grid[this.loc[1]][this.loc[0] + 1] != (byte) '1' ? 1 : 2; }else { this.SelectArea[2] = 1; } //设置光标的高度 if (this.loc[1] + 1 ＜ Images.HEIGHT) { this.SelectArea[3] = this.MyMap.Grid[this.loc[1] + 1][this.loc[0]] != (byte) '2' ? 1 : 2; }else { this.SelectArea[3] = 1; } } private boolean setMoveRange() { //设置要移动到的区域，能够移动返回true,否则返回false for (int i = 0; i ＜ this.SelectArea[2]; i++) { for (int j = 0; j ＜ this.SelectArea[3]; j++) { if (this.loc[1] + j ＞= Images.HEIGHT || this.loc[0] + i ＞= Images.WIDTH || (!isInRange(this.loc[0] + i, this.loc[1] + j) && this.MyMap.Grid[this.loc[1] + j][this.loc[0] + i] != Images.BLANK)) { return false; } } } this.MoveArea[0] = this.loc[0]; this.MoveArea[1] = this.loc[1]; this.MoveArea[2] = this.SelectArea[2]; this.MoveArea[3] = this.SelectArea[3]; return true; } private boolean isInRange(int x, int y) { //判断给定的（x，y）点是否在选定区域之内，x是水平坐标，y是竖直坐标 if (x ＞= this.SelectArea[0] && x ＜ this.SelectArea[0] + this.SelectArea[2] && y ＞= this.SelectArea[1] && y ＜ this.SelectArea[1] + this.SelectArea[3]) { return true; }else { return false; } } private boolean isInRange2(int x, int y) { //判断给定的（x，y）点是否在要移动到的区域之内，x是水平坐标，y是竖直坐标 if (x ＞= this.MoveArea[0] && x ＜ this.MoveArea[0] + this.MoveArea[2] && y ＞= this.MoveArea[1] && y ＜ this.MoveArea[1] + this.MoveArea[3]) { return true; }else { return false; } } protected void keyPressed(int keyCode) { //处理按下键盘的事件，这是Canvas的实例方法 switch (getGameAction(keyCode)) {//将按键的值转化成方向常量 case Canvas.UP://向上 if (!this.selected) {//还没有选定要移动的区域 if (this.loc[1] - 1 ＞= 0) {//向上还有移动空间 this.loc[1]--;//向上移动一下 setRange();//设置光标移动的区域，该函数能将光标移动到地图主位置 repaint();//重新绘图 } }else {//已经选定了要移动的区域 if (this.loc[1] - 1 ＞= 0) {//向上还有移动空间 this.loc[1]--;//向上移动一下 if (setMoveRange()) {//能够移动，该函数能够设置要移动到的区域 repaint();//重新绘图 }else {//不能移动 this.loc[1]++;//退回来 } } } break; case Canvas.DOWN://向下 if (!this.selected) {//还没有选定要移动的区域 if (this.loc[1] + 1 ＜ Images.HEIGHT) {//向下还有移动空间 if (this.MyMap.Grid[this.loc[1] + 1][this.loc[0]] == Images.DUP){//该图片有两个格高 this.loc[1]++;//向下移动一下 if (this.loc[1] + 1 ＜ Images.HEIGHT) {//向下还有 ＜A href="file://移"＞file://移＜/A＞动空间 this.loc[1]++;//向下移动一下 setRange();//设置光标移动的区域， ＜A href="file://该"＞file://该＜/A＞函数能将光标移动到地图主位置 repaint();//重新绘图 }else {//向下没有移动空间 this.loc[1]--;//退回来 } }else {//该图片只有一个格高 this.loc[1]++;//向下移动一下 setRange();//设置光标移动的区域， ＜A href="file://该"＞file://该＜/A＞函数能将光标移动到地图主位置 repaint();//重新绘图 } }else { } }else {//已经选定了要移动的区域 if (this.loc[1] + 1 ＜ Images.HEIGHT) {//向下还有移动空间 this.loc[1]++;//向下移动一下 if (setMoveRange()) {//能够移动，该函数能够设置要移动到的区域 repaint();//重新绘图 }else {//不能移动 this.loc[1]--;//退回来 } } } break; case Canvas.LEFT://向左 if (!this.selected) {//还没有选定要移动的区域 if (this.loc[0] - 1 ＞= 0) {//向左还有移动空间 this.loc[0]--;//向左移动一下 setRange();//设置光标移动的区域，该函数能将光标移动到地图主位置 repaint();//重新绘图 } }else {//已经选定了要移动的区域 if (this.loc[0] - 1 ＞= 0) {//向左还有移动空间 this.loc[0]--;//向左移动一下 if (setMoveRange()) {//能够移动，该函数能够设置要移动到的区域 repaint();//重新绘图 }else {//不能移动 this.loc[0]++;//退回来 } } } break; case Canvas.RIGHT://向右 if (!this.selected) {//还没有选定要移动的区域 if (this.loc[0] + 1 ＜ Images.WIDTH) {//向右还有移动空间 if (this.MyMap.Grid[this.loc[1]][this.loc[0] + 1] == Images.DLEFT) {//该图片有两个格宽 this.loc[0]++;//向右移动一下 if (this.loc[0] + 1 ＜ Images.WIDTH) {//向右还有 ＜A href="file://移"＞file://移＜/A＞动空间 this.loc[0]++;//向右移动一下 setRange();//设置光标移动的区域， ＜A href="file://该"＞file://该＜/A＞函数能将光标移动到地图主位置 repaint();//重新绘图 }else {//向右没有移动空间 this.loc[0]--;//退回来 } }else {//该图片只有一个格宽 this.loc[0]++;//向右移动一下 setRange();//设置光标移动的区域， ＜A href="file://该"＞file://该＜/A＞函数能将光标移动到地图主位置 repaint();//重新绘图 } }else { } }else {//已经选定了要移动的区域 if (this.loc[0] + 1 ＜ Images.WIDTH) {//向右还有移动空间 this.loc[0]++;//向右移动一下 if (setMoveRange()) {//能够移动，该函数能够设置要移动到的区域 repaint();//重新绘图 }else {//不能移动 this.loc[0]--;//退回来 } } } break; case Canvas.FIRE: if (this.selected) {//已经选定了要移动的区域 Move();//将要移动的区域移动到刚选中的区域 repaint();//重新绘图 this.selected = false;//清除已选定要移动区域的标志 if ( win()) { System.out.println("win"); } }else {//还没有选定要移动的区域 if (this.MyMap.Grid[this.loc[1]][this.loc[0]] == Images.BLANK) {//要移到的位置是一个空白 }else {//要移到的位置不是空白 this.selected = true;//设置已选定要移动区域的标志 } repaint();//重新绘图 } break; } } private boolean win(){ ＜A href="file://判"＞file://判＜/A＞断是否已经救出了曹操 if ( this.MyMap.Grid[Images.HEIGHT - 2 ][Images.WIDTH - 3 ] == Images.CAOCAO ) return true; else return false; } private void PrintGrid(String a) { ＜A href="file://打"＞file://打＜/A＞印当前地图的内容，用于调试 System.out.println(a); for (int i = 0; i ＜ Images.HEIGHT; i++) { for (int j = 0; j ＜ Images.WIDTH; j++) { System.out.print( (char)this.MyMap.Grid[i][j]); } System.out.println(""); } } private void Move() { ＜A href="file://将"＞file://将＜/A＞要移动的区域移动到刚选中的区域 if (this.MoveArea[0] == -1 || this.MoveArea[1] == -1 || this.SelectArea[0] == -1 || this.SelectArea[1] == -1) {//没有选中区域 }else {//已经选中了要移动的区域和要移动到的区域 byte[][] temp = new byte[this.SelectArea[3]][this.SelectArea[2]]; ＜A href="file://复"＞file://复＜/A＞制要移动的区域，因为这块区域可能会被覆盖掉 for (int i = 0; i ＜ this.SelectArea[2]; i++) { for (int j = 0; j ＜ this.SelectArea[3]; j++) { temp[j][i] = this.MyMap.Grid[this.SelectArea[1] +j] [this.SelectArea[0] + i]; } } ＜A href="file://PrintGrid"＞file://PrintGrid＜/A＞("1"); // 调试信息 ＜A href="file://将"＞file://将＜/A＞要移动的区域移动到刚选中的区域（即要移动到的区域） for (int i = 0; i ＜ this.SelectArea[2]; i++) { for (int j = 0; j ＜ this.SelectArea[3]; j++) { this.MyMap.Grid[this.MoveArea[1] + j] [this.MoveArea[0] + i] = temp[j][i]; } } ＜A href="file://PrintGrid"＞file://PrintGrid＜/A＞("2");// 调试信息 ＜A href="file://将"＞file://将＜/A＞要移动的区域中无用内容置成空白 for (int i = 0; i ＜ this.SelectArea[3]; i++) { for (int j = 0; j ＜ this.SelectArea[2]; j++) { if (!isInRange2(this.SelectArea[0] + j, this.SelectArea[1] + i)) {//该点是不在要移动到 ＜A href="file://的"＞file://的＜/A＞区域之内，需置空 this.MyMap.Grid[this.SelectArea[1] + i] [this.SelectArea[0] + j] = Images.BLANK; }else { } } } ＜A href="file://PrintGrid"＞file://PrintGrid＜/A＞("3");// 调试信息 this.SelectArea[0] = this.MoveArea[0];//重置选中位置的水平坐标 this.SelectArea[1] = this.MoveArea[1];//重置选中位置的竖直坐标 this.MoveArea[0] = -1;//清空要移动到的位置 this.MoveArea[1] = -1;//清空要移动到的位置 this.MoveArea[2] = 0;//清空要移动到的位置 this.MoveArea[3] = 0;//清空要移动到的位置 } } }

　　代码的相关分析,在详细设计阶段已经讲过,代码中有比较相近的注释,请读者自行研读分析.将全部的代码写好,用wtk2.0自带的Ktoolbar工具建立一个工程,接下来把去不源文件放到正确位置下,然后点击build,再点run,就完成了程序的编写.当然如果有错误还要修改和调试.

　　七、测试

　　作为一个真正的产品要经过单体测试、结合测试和系统测试。由于项目本身简单,而且大部分代码已经是相对成熟的,我们跳过单体测试；又由于笔者的实际环境所限,无法搞到Java手机,无法架设OTA服务器,因此我们也只能放弃系统测试。那么就让我们开始结合测试吧。测试之前要先出一个测试式样书,也就是测试的计划。我们将它简化一下,只测试如下几种情况:第一、对各种形状的区域的选择和移动;第二、临近边界区域的选择和移动;第三、同一区域的反复选择和反复移动;第四、非法选择和非法移动。有了测试的目标,接下来的工作就是用wtk2.0自带的Run MIDP Application工具进行测试。打开这个工具,加载huarongRoad的jad文件,程序就会自动运行,选择launch上MIDlet1这个程序,华容道游戏就会跃然屏幕之上,接下来的工作就是左三点.右三点,拇指扭扭,来做测试。测试过程中发现任何的问题,立刻发一个bug票给自己,然后就又是痛苦的调试和修正bug,如此如此。

　　八.发布

　　谈到发布,其实是个关键,再好的产品不能很好的发布出去也只是个产品而已,变不成商品也就得不到回报.由于笔者的条件所限,这里只能是纸上谈兵,不过还是希望能够使读者对这一过程有所了解(网上的资料也很多)。

　　J2ME的程序发布一般都是通过OTA(Over The Air),你只需要一台有公网IP的主机和一个普通的web Server就可以了(尽管要求很低,但笔者还是没有)，这里我们以apache为例介绍一下OTA服务的配置，首先是安装好了apache服务器，然后在conf目录下找到mime.types文件，在该文件中加入如下两行

application/java-archive jar
text/vnd.sun.j2me.app-descriptor jad

　　然后重起apache服务器就可以了。接下来的工作就是修改jad文件中MIDlet-Jar-URL:后面的参数，将它改为URL的绝对路径，即＜A href="http://***/"＞http://***/＜/A＞huarongroad.jar(其中***是你的域名或IP地址)。在下面就是用java手机下载jad文件，它会自动部署相应的jar文件并加载它。剩下的工作就和在模拟器上操作是一样的了。

　　九、项目总结

　　至此，我们已经完成了一个J2ME游戏的全部开发过程，程序中涉及到了调研、分析、设计、编码、测试和发布等方面的问题，其实在实际的工作中还有很多更为具体的问题，毕竟技术只在软件开发过程中占据很有限的一部分，这里限于篇幅的限制无法一一具体展开。今后，笔者计划再写一篇使用J2ME开发手机屏保的文章，借此机会向读者展示J2ME动画技术；然后再写一篇J2ME网络应用的文章，做一个类似开心辞典那样的知识问答游戏，以便向读者展示J2ME的网络技术；待这两方面的技术交待清楚之后，我将引领读者制作一个稍大一些的游戏。

1.         使用Runnable和创建线程的主循环

一般主体的做法就是让Displayable这个类实现Runnable这个接口，然后在其构造函数中创建一个线程，启动其run()函数,而run函数里面就包含了游戏的主循环。下面是我在仙剑里面的片断代码。

public class GameMIDlet extends MIDlet {

  static GameMIDlet instance;

  Display display;

  GameDisplayable displayable = null;

  public GameMIDlet() {

    instance = this;

    display =  Display.getDisplay(this);

    displayable = new GameDisplayable();

  }

  public void startApp() {

    display.setCurrent(displayable);

  }

  public void pauseApp() {

  }

  public void destroyApp(boolean unconditional) {

    displayable.running = false;

  }

  public static void quitApp() {

    instance.destroyApp(true);

    instance.notifyDestroyed();

    instance = null;

  }

}

public class GameDisplayable extends FullCanvas implements Runnable {

  /** 主控制线程 */

  Thread MainThread = null;

  /** 游戏时钟间隔 毫秒为单位 */

  public static long timeinterval = 20;

  public static boolean Isstable = true;

  /* 用于游戏时钟的变量 */

  public static long timeold = 0;

  public static long timenow = 0;

  public long interval = 0;

  public static long frames_per_second = 0;

  int count = 0;

  long second = 0;

  public static boolean running = true;

public GameDisplayable() {

      // 开始主线程

    Thread MainThread = new Thread(this);

    MainThread.start();

  }

public void run() {

    while (running) {

      timenow = System.currentTimeMillis();

      interval = timenow - timeold;

      if (interval >= timeinterval) {

        timeold = timenow;

        Game_Process();

        if (second != (System.currentTimeMillis() / 1000)) {

          second = System.currentTimeMillis() / 1000;

          frames_per_second = count;

          count = 1;

        }

        else

          count++;

      }

      lib.sleep(30);

    }

 }

其中关于控制主循环速度的代码可以不要，但是lib.sleep(30)必须保留，因为在Nokia 60的手机上，如果去除了sleep(30),那么游戏将无法切换回来。同时，在游戏中任何一个内部循环中，也必须加入sleep(30)这个等待，才能让游戏可以切换回来，至于为什么这样做，我暂时还不清楚。30ms是我测试过没有问题的数值，可能比30ms还小的值也是没有问题的。

同时，在MOTO的手机上，必须将游戏的主循环放在一个线程中，游戏才能切换回来，不过可以不加上面说的sleep(30)延时。

2.         不使用线程的主循环办法

这个办法只能在Nokia的平台上实现，而我只建议在Nokia 40的平台上做，这样不需要线程，道理上来说节约了一些内存，如果不是内存很紧张的机型，那么最好还是使用上一种办法。

游戏的主循环放在MIDlet的class里面，具体做法如下：

public class GameMIDlet extends MIDlet {

  GameDisplayable displayable = null;

  /** 游戏时钟间隔 毫秒为单位 */

  public static long  timeinterval = 0;

  //用于游戏时钟的变量

  public static long timeold = 0;

  public static long timenow = 0;

  public long interval = 0;

  public static long frames_per_second=0;

  int count=0;

  long second =0;

  public static boolean running = false;

  static boolean exitApp =false;

  public GameMIDlet() {

    displayable = new GameDisplayable();

    running =true;

  }

  public void startApp() {

    running =true;

    Display.getDisplay(this).setCurrent(displayable);

    while(running) {

      timenow = System.currentTimeMillis();

      interval = timenow - timeold;

      if (interval >= timeinterval) {

        timeold = timenow;

        displayable.Game_Process();

        if(second != (System.currentTimeMillis() /1000)){

            second = System.currentTimeMillis()/1000;

            frames_per_second = count;

            count = 1;

          }else

            count ++;

      }

    }

    if(exitApp) {

      destroyApp(true);

      notifyDestroyed();

    }

  }

  public void pauseApp() {

    running =false;

  }

  public void destroyApp(boolean unconditional) {

    running = false;

  }

  public static void quitApp() {

    running =false;

    exitApp =true;

  }

}

　　角色扮演游戏(RPG)是深受广大游戏迷们喜爱的一种游戏, 它以独特的互动性和故事性吸引了无数的玩家。它向人们提供了超出现实生活的广阔的虚拟世界，使人们能够尝试扮演不同的角色，去经历和体验各种不同的人生旅程或奇幻经历。这些体验都是在现实生活中无法实现的。在玩过许多游戏后，许多玩家都不再仅仅满足于一个游戏玩家的身份，而会思考游戏是如何制作的，并且打算制作一个自己的游戏，网上的各种游戏制作小组更是如雨后春笋般涌现。下面我就给大家介绍一下角色扮演游戏引擎的原理与制作，希望能对游戏制作爱好者有所帮助。

一 游戏引擎的原理

　　说到引擎，游戏迷们都很熟悉。游戏引擎是一个为运行某一类游戏的机器设计的能够被机器识别的代码（指令）集合。它象一个发动机，控制着游戏的运行。一个游戏作品可以分为游戏引擎和游戏资源两大部分。游戏资源包括图象，声音，动画等部分，列一个公式就是：游戏=引擎（程序代码）+资源（图象，声音，动画等）。游戏引擎则是按游戏设计的要求顺序的调用这些资源。

二 角色扮演游戏的制作

　　一个完整的角色扮演游戏的制作从大的分工来说可以分为：策划，程序设计，美工，音乐制作以及项目管理，后期的测试等。
　　策划主要任务是设计游戏的剧情，类型以及模式等，并分析游戏的复杂性有多大，内容有多少，策划的进度要多快等因素。
　　程序设计的任务是用某种编程语言来完成游戏的设计，并与策划配合，达到预期的目的。
　　美工主要是根据游戏的时代背景与主题设计游戏的场景及各种角色的图象。
　　音乐制作是根据游戏的剧情和背景制作游戏的音乐与音效。
　　项目管理主要是控制游戏制作的进程，充分利用现有的资源（人员，资金，设备等），以达到用尽量少的资金实现最大的收益。
　　后期的测试也是非常重要的一个环节，对于一个几十人花费几个月甚至是几年时间制作的游戏，测试往往能找到许多问题，只有改进程序才能确保游戏的安全发行。
　　由于文章主要是讲解游戏程序的制作的，所以策划，美工，音乐制作等方面请读者参考其它文章，下面我就讲讲游戏程序的设计。

(一) 开发工具与主要技术

1．件开发工具

　　游戏程序开发工具有很多，在不同游戏平台上有不同的开发工具。在个人计算机上，可以用目前流性的软件开发工具，比如：C，C++，VC++，Delphi，C++ Builder等。由于Windows操作系统的普及和其强大的多媒体功能，越来越多的游戏支持Windows操作系统。由于VC是微软的产品，用它来编写Windows程序有强大的程序接口和丰富的开发资源的支持，加之VC严谨的内存管理，在堆栈上良好的分配处理，生成代码的体积小，稳定性高的优点，所以VC++就成为目前游戏的主流开发工具。

2．DirectX组件的知识

　　谈到Windows系统下的游戏开发，我们就要说一下微软的DirectX SDK。
　　Windows系统有一个主要优点是应用程序和设备之间的独立性。然而应用程序的设备无关性是通过牺牲部分速度和效率的到的，Windows在硬件和软件间添加了中间抽象层，通过这些中间层我们的应用程序才能在不同的硬件上游刃有余。但是，我们因此而不能完全利用硬件的特征来获取最大限度的运算和显示速度。这一点在编写Windows游戏时是致命的，DirectX便是为解决这个问题而设计的。DirectX由快速的底层库组成并且没有给游戏设计添加过多的约束。微软的DirectX软件开发工具包（SDK）提供了一套优秀的应用程序编程接口（APIs），这个编程接口可以提供给你开发高质量、实时的应用程序所需要的各种资源。
　　DirectX的6个组件分别是：
　　　　DirectDraw： 使用页面切换的方法实现动画，它不仅可以访问系统内存，还可以访问显示内存。
　　　　Direct3D： 提供了3D硬件接口。
　　　　DirectSound： 立体声和3D声音效果，同时管理声卡的内存。
　　　　DirectPlay： 支持开发多人网络游戏，并能处理游戏中网络之间的通信问题。
　　　　DirectInput： 为大量的设备提供输入支持。
　　　　DirectSetup： 自动安装DirectX驱动程序。
　　随着DirectX版本的提高，还增加了音乐播放的DirectMusic。

3．AlphaBlend 技术

　　现在许多游戏为了达到光影或图象的透明效果都会采用AlphaBlend 技术。所谓AlphaBlend技术，其实就是按照"Alpha"混合向量的值来混合源像素和目标像素，一般用来处理半透明效果。在计算机中的图象可以用R(红色)，G(绿色)，B(蓝色)三原色来表示。假设一幅图象是A，另一幅透明的图象是B，那么透过B去看A，看上去的图象C就是B和A的混合图象，设B图象的透明度为alpha(取值为0-1，0为完全透明，1为完全不透明)，Alpha混合公式如下：
　　　　R(C)=alpha*R(B)+(1-alpha)*R(A)
　　　　G(C)=alpha*G(B)+(1-alpha)*G(A)
　　　　B(C)=alpha*B(B)+(1-alpha)*B(A)
　　R(x)、G(x)、B(x)分别指颜色x的RGB分量原色值。从上面的公式可以知道，Alpha其实是一个决定混合透明度的数值。应用Alpha混合技术，可以实现游戏中的许多特效，比如火光、烟雾、阴影、动态光源等半透明效果。

4．A*算法

　　在许多游戏中要用鼠标控制人物运动，而且让人物从目前的位置走到目标位置应该走最短的路径。这就要用到最短路径搜索算法即A*算法了。
　　A*算法实际是一种启发式搜索，所谓启发式搜索，就是利用一个估价函数评估每次的的决策的价值，决定先尝试哪一种方案。如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：
　　　　f(n) = g(n) + h(n)
　　这里，f(n)是节点n的估价函数，g(n)是起点到终点的最短路径值，h(n)是n到目标的最断路经的启发值。由于A*算法比较复杂，限于篇幅，在此简单介绍一下，具体理论朋友们可以看人工智能方面的书籍了解详细的情况。

　　其它技术还有粒子系统，音频与视频的调用，图象文件的格式与信息存储等，大家可以在学好DirectX的基础上逐渐学习更多的技术。

（二）游戏的具体制作

1．地图编辑器的制作

　　RPG游戏往往要有大量的场景，场景中根据需要可以有草地，湖泊，树木，房屋，家具等道俱，由于一个游戏需要很多场景且地图越来越大，为了节省空间，提高图象文件的可重用性，RPG游戏的画面采用很多重复的单元（可以叫做“图块”）所构成的，这就要用到地图编辑器了。我们在制作游戏引擎前，要完成地图编辑器的制作。在 RPG游戏里，场景的构成，是图块排列顺序的记录。首先制定一个场景构成文件的格式，在这个文件里记录构成场景所需要的图块的排列顺序，因为我们已经为每个图块建立了索引，所以只需要记录这些索引就可以了。一个场景的构成，是分成几层来完成的：地面，建筑和植物，家具摆设，和在场景中活动的人物或者物体（比如飘扬的旗帜），按照一定的顺序把它们依次显示到屏幕上，就形成了一个丰富多采的场景。我们可以用数组来表示地图场景的生成过程。

MapData[X][Y]； //地图数据，X表示地图宽度，Y表示地图高度
Picture[num]； //道具的图片，num表示道具的总数
void MakeBackGround() //生成场景函数
{
　int n;
　for( int i=0; i<Y; i++) //共Y行
　for( int j=0; j<X; j++) //共X列
　{
　　n=MapData[ i ][ j ]; //取得该位置的道具编号
　　Draw( j*32, i*32, Picture[n]); //在此位置(j*32,i*32)画道具
　}
}

2．游戏的模块的划分

　　游戏按功能分为：消息处理系统、场景显示及行走系统、打斗系统三大主要部分。其中又以消息处理系统为核心模块，其余部分紧紧围绕它运行。

一：消息处理系统

　　消息处理系统是游戏的核心部分。游戏用到的消息处理系统先等待消息，然后根据收到的消息转到相应的函数进行处理。比如：主角碰到敌人后，我们就让程序产生‘打斗消息’，消息处理系统收到这个消息后就会马上转到打斗模块中去。消息处理的大体框架如下：

//定义程序中要用到的变量
DWORD Message; //消息变量
WinMain() //进入程序
{
　初始化主窗口;
　初始化DirectDraw环境，并调入程序需要的图形、地图数据；
　while( 1 ) //消息循环
　{
　　switch( Message )
　　{
　　　case 行走消息: 行走模块();
　　　case 打斗消息： 打斗模块();
　　　case 事件消息： 事件模块();
　　}
　}
}

二：场景显示及行走系统

　　作为RPG游戏，其所有事件的发生几乎都是和场景有关，例如：不同的地方会碰到不同的敌人、与不同的人对话得知不同的事情等。鉴于这部分的重要性，我们可再将它划分为：背景显示、行走 和 事件发生 三个子模块，分别处理各自的功能。下面进行具体分析。

（一）背景显示
　　程序运行后，先读取前面地图编辑器制作的场景所需要的图块的排列顺序，按照排列顺序将图象拼成一个完整的场景，一般做法是：在内存中开辟一到两个屏幕缓存区，事先把即将显示的图象数据准备在缓存区内，然后一次性搬家：把它们传送到真正的屏幕缓冲区内。
　　游戏用到的图片则事先制作好并存于另外的图形文件中。地图编辑器制作的场景文件仅仅是对应的数据，而不是真正的图片。在游戏中生成场景就是地图编辑的逆过程，一个是根据场景生成数据，而另一个是根据数据生成场景。

（二）行走
　　要让主角在场景中行走，至少要有上、下、左、右四个行走方向，每个方向4幅图（站立、迈左腿、迈右腿、迈左腿），如图：游戏中一定要将图片的背景设为透明，这样在画人物的时候就不会覆盖上背景色了（这一技术DirectDraw中只要用SetColorKey（）函数将原图片背景色过滤掉就行了）。我们让主角位置不动，而使场景移动，即采用滚屏技术来实现角色在场景上移动。这样角色一直保持在屏幕的正中间，需要做的工作只是根据行走方向和步伐不停变换图片而已。行走时的障碍物判断也是每一个场景中必定要有的，有一些道具如树木、房屋等是不可跨越的。对此我主要用一个二维数组来对应一个场景，每一个数组值代表场景的一小格(见图3)。有障碍的地方，该数组的对应值为1，可通过的地方的值为0。

（三）事件发生
　　事件发生原理就是把相应事件的序号存储在地图的某些格子中，当主角一踏入这个格子就会触发对应事件。例如：在游戏开始时，主角是在他的家里。他要是想出去的话，就需要执行场景切换这个处理函数。我们假定该事件的编号为001，那么在地图上把家门外路口处的格子值设为001。这样主角走到路口时，编号为001的场景切换函数就会被触发，于是主角便到了下一个场景中。程序具体如下：

void MessageLoop( int Msg ) //消息循环
{
　switch( Msg )
　{
　　char AddressName[16]; //数组AddressName[16]用来存储主角所在地点的名称
　　case ADDRESS == 001: // 由ADDRESS的值决定场景值（出门）
　　ScreenX=12; ScreenY=0; //初始化游戏背景位置
　　Hero.x=360; Hero.y=80;//主角坐标
　　Move();//主角移动函数
　　//以下程序用来显示主角所在地点
　　sprintf(AddressName,"下一幅游戏场景的名称");
　　PrintText(lpDDSPrimary, 280, 330,AddressName , RGB(255,255,255));//在屏幕上显示出场景的名称
　　break;
　}
}

三：打斗系统

　　绝大多数的RPG都是有战斗存在的，因此，打斗系统就成为RPG系统中很重要的一环。有不少RPG游戏采用回合制打斗方式，因为实现起来较为简单。和打斗紧密相关的是升级，通常在一场战斗结束后，主角的经验值都会增加。而当经验值到达一定程度时，角色就升级了。
　　上面我简要的介绍了角色扮演游戏的制作，由于写这篇文章的目的是让读者对角色扮演游戏的制作有一个基本的了解，所以读者朋友们可以研究相关资料。