Java & Game » j2me http://www.javagg.com java&j2me Sat, 02 Jul 2011 08:59:18 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 J2ME中RMS的使用解析 http://www.javagg.com/archives/825 http://www.javagg.com/archives/825#comments Wed, 20 Oct 2010 02:36:48 +0000 纯净水 http://www.javagg.com/?p=825 在J2ME中，RMS作为唯一的永久性存储工具，其重要性是不言而喻的。但是很多刚刚开始学习J2ME的新人总是抱怨在这方面的资料很少，或者是针对性不强。因此，我想把自己在这方面的一些学习心得和大家交流一下。
RMS即Record Manager System，在手机应用中常常作为得分记录、游戏信息存储等的工具使用。
RMS的使用可以分为两个部分：一、单一记录的构造；二、RecordStore的使用和操作。下面就这两方面进行详细说明。
一、单一记录的构造。我们在存储记录时可能需要记录很多相似的条目，在这里我们可以把这种结构看成数据库，我们在这一步就是要构造数据库中的一行，即单一记录的构造。程序的源码如下：

  1.  
  2. package com.cuilichen.usual;
  3.  
  4. import java.io.ByteArrayInputStream;//要使用到的各种输入输出流
  5. import java.io.ByteArrayOutputStream;
  6. import java.io.DataInputStream;
  7. import java.io.DataOutputStream;
  8.  
  9. public class Appointment {//单一记录的类名
  10. private int int1; //
  11. private int int2; //
  12. private long long1;
  13. private String str1; //str1作为保留字段，记录检索的关键字
  14. private String str2; //
  15. private String str3; //
  16. private boolean WroteFlag; //
  17.  
  18. public Appointment() {
  19. }
  20.  
  21. public Appointment(int _int1, int _int2, long _long1, String _str1,
  22. String _str2, String _str3, boolean _WroteFlag) {
  23. this.int1 = _int1; //写入RMS的构造函数
  24. this.int2 = _int2;
  25. this.long1 = _long1;
  26. this.str1 = _str1;
  27. this.str2 = _str2;
  28. this.str3 = _str3;
  29. this.WroteFlag = _WroteFlag;
  30. }
  31.  
  32. public Appointment(byte[] rec) {
  33. initAppointmnet(rec); //读取RMS内容的构造函数
  34. }
  35.  
  36. public byte[] toBytes() { //写成字节
  37.  
  38. byte[] data = null;
  39.  
  40. try {
  41. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  42. DataOutputStream dos = new DataOutputStream(baos);
  43. dos.writeInt(int1);
  44. dos.writeInt(int2);
  45. dos.writeLong(long1);
  46. dos.writeUTF(str1);
  47. dos.writeUTF(str2);
  48. dos.writeUTF(str3);
  49. dos.writeBoolean(WroteFlag);
  50. data = baos.toByteArray();
  51. baos.close();
  52. dos.close();
  53. } catch (Exception e) {
  54. e.printStackTrace();
  55. }
  56. return data;
  57. }
  58.  
  59. public void initAppointmnet(byte[] rec) { //从字节读取内容
  60.  
  61. ByteArrayInputStream bais = new ByteArrayInputStream(rec);
  62. DataInputStream dis = new DataInputStream(bais);
  63.  
  64. try {
  65. int1 = dis.readInt();
  66. int2 = dis.readInt();
  67. long1 = dis.readLong();
  68. str1 = dis.readUTF();
  69. str2 = dis.readUTF();
  70. str3 = dis.readUTF();
  71. WroteFlag = dis.readBoolean();
  72. } catch (Exception e) {
  73. e.printStackTrace();
  74. }
  75. }
  76.  
  77. public int getInt1() { //int
  78. return int1;
  79. }
  80. public int getInt2() {
  81. return int2;
  82. }
  83. public long getLong1() {
  84. return long1;
  85. }
  86.  
  87. public String getStr1() { //String
  88. return str1;
  89. }
  90.  
  91. public String getStr2() { //String
  92. return str2;
  93. }
  94.  
  95. public String getStr3() {
  96. return str3;
  97. }
  98.  
  99. public boolean getWroteFlag() { //返回写入标志
  100. return WroteFlag;
  101. }
  102. }
  103.  

这个类的使用保证了我们在使用流时，内容的写入和输出。当然，就如同数据库表的设计一样，我们可以任意对每一条记录增加或减少字段，在上面的类中我只使用了int1，int2，long1，str1，str2，str3和WroteFlag一共7个字段
二、RecordStore的操作。类RMS如下：

  1.  
  2. package com.cuilichen.usual;
  3.  
  4. import javax.microedition.rms.RecordEnumeration;
  5. import javax.microedition.rms.RecordStore;
  6.  
  7. public class RMS {
  8. public static final int Int1 = 0;//各个字段的默认数值
  9. public static final int Int2 = 0;
  10. public static final long Long1 = 0;
  11. public static final String Str1 = "";
  12. public static final String Str2 = "";
  13. public static final String Str3 = "";
  14.  
  15. public static boolean addRecord(String name, int int1, int int2,//添加记录
  16. long long1, String str1, String str2, String str3, boolean b) {
  17. boolean success = false;
  18.  
  19. try {
  20. RecordStore rs = RecordStore.openRecordStore(name, true);
  21. Appointment app = new Appointment(int1, int2, long1, str1, str2,str3, b);
  22. //既然str1作为保留字段，我们在这里就要如此操作：例如int1为我们设定的关键字，那么str1 = Integer.toString(int1);
  23. byte[] data = app.toBytes();
  24. rs.addRecord(data, 0, data.length);
  25. rs.closeRecordStore();
  26. success = true;
  27. } catch (Exception e) {
  28. e.printStackTrace();
  29. }
  30. return success;
  31. }
  32. public static int getNumOfRecords(String name) {//得到RMS中记录的条数
  33. try {
  34. RecordStore rs = RecordStore.openRecordStore(name, true);
  35.  
  36. return rs.getNumRecords();
  37. } catch (Exception e) {
  38. return 0;
  39. }
  40. }
  41.  
  42. public static Appointment[] getRecords(String name) {//取得RMS中的所有记录
  43. Appointment[] result = { };
  44.  
  45. try {
  46. RecordStore rs = RecordStore.openRecordStore(name, false);
  47. RecordEnumeration re = rs.enumerateRecords(null, null, false);
  48. result = new Appointment[rs.getNumRecords()];
  49.  
  50. for (int i = 0; i < result.length; i++) {
  51. int j = re.previousRecordId();
  52. Appointment app = new Appointment(rs.getRecord(j));
  53. result[i] = app;
  54.  
  55. //System.out.println("app["+i+"] "+app.getStr2());
  56. }
  57.  
  58. rs.closeRecordStore();
  59. } catch (Exception e) {
  60. }
  61.  
  62. return result;
  63. }
  64.  
  65. public static Appointment getRecord(String name, int j) {//根据记录编号（参数 int j）取得一条记录
  66. Appointment result = new Appointment();
  67.  
  68. try {
  69. RecordStore rs = RecordStore.openRecordStore(name, false);
  70. RecordEnumeration re = rs.enumerateRecords(null, null, false);
  71. result = new Appointment(rs.getRecord(j));
  72. rs.closeRecordStore();
  73. } catch (Exception e) {
  74. }
  75.  
  76. return result;
  77. }
  78.  
  79. public static int getIndex(String name, String content) {//得到记录号int j，这里需要使用保留字段str1
  80. RecordStore rs = null;
  81. RecordEnumeration re = null;
  82.  
  83. try {
  84. rs = RecordStore.openRecordStore(name, false); //open
  85. re = rs.enumerateRecords(null, null, false); //enumeration
  86.  
  87. for (int i = 0; i < RMS.getNumOfRecords(name); i++) {
  88. int j = re.nextRecordId();
  89. Appointment app = new Appointment(rs.getRecord(j));
  90.  
  91. if (app.getStr1().equals(content)) {
  92.  
  93. return j;
  94. }
  95. }
  96. } catch (Exception e) {
  97. }
  98. return 1;
  99. }
  100.  
  101. public static boolean setRecord(String name, int id, int int1, int int2,//设置记录号为id的记录
  102. long long1, String str1, String str2, String str3, boolean b) {
  103. boolean success = false;
  104. RecordStore rs = null;
  105. RecordEnumeration re = null;
  106.  
  107. try {
  108. rs = RecordStore.openRecordStore(name, false); //open
  109. re = rs.enumerateRecords(null, null, false); //enumeration
  110.  
  111. Appointment app = new Appointment(int1, int2, long1, str1, str2, str3, b);
  112. //str1作为保留字段，在这里如此操作：例如若int1为我们设定的关键字，那么str1 = Integer.toString(int1);
  113.  
  114. byte[] data = app.toBytes();
  115. rs.setRecord(id, data, 0, data.length);
  116. success = true;
  117. rs.closeRecordStore();
  118. } catch (Exception e) {
  119. }
  120.  
  121. return success;
  122. }
  123. }
  124.  

在这个类中，我没有将各个Exception向外抛出，一般来说这样作是不合适的，它违背了Java的异常处理机制。但是在我使用这个类的各个J2ME程序中，它是可以胜任的，所以也就没有进行进一步的修改。
有了以上的两个类和你对RMS的理解，在程序中，你就可以顺畅的使用RMS了。
比如在MIDlet开始时，如下操作（增加记录）：
protected void startApp() throws MIDletStateChangeException {
if (RMS.getNumOfRecords(rsName) = = 0) {//rsName在前面已经声明了。String rsName＝“MyRMS”；
for (int i = 0; i <6; i++) {
RMS.addRecord(rsName, RMS.Int1, i, RMS.Long1, Integer . toString(i), RMS.Str2, “1234567890123456789″,false);
}
}它就在RMS中增加了6条记录，其中int1，long1，str2，WroteFlag都没有使用，我们只是使用int2，str1（作为保留字段）和str3。

]]> http://www.javagg.com/archives/825/feed 0 j2me经验总结之URLEncoding http://www.javagg.com/archives/815 http://www.javagg.com/archives/815#comments Wed, 25 Aug 2010 03:06:21 +0000 纯净水 http://www.javagg.com/?p=815 URLEncoding是用于解决链接字符串中包含中文字符的一种转换编码。各种编程环境下几乎带有它的库函数。

不过，J2ME除外。

好在JAVA的源代码中带有这个类，我们把它拷贝到J2ME环境下编译到我们的应用当中就可以了。

该文件位于JDK的目录下src.zip文件中，名叫URLEncoder.java。

但是，这个文件还需要做很多修改才能使用在J2ME环境中。

先警告大家，有几个真机，不管输入什么样的Encodeing都会出错，甚至是“UTF-8”。所以我一怒之下去除了Encodeing参数。（这可是在实际应用中得出的结论，不去掉的话可以在大部分情况下正常使用，但是，现实总是有点缺陷）

修改后的代码如下，大家请放心使用。如果有兴趣，可以比较两个代码，看看我改动了什么地方。

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
public class HURLEncoder {

 private static boolean[] dontNeedEncoding;

 static {
  dontNeedEncoding = new boolean[256];

  for (int i = 0; i < 256; i++) {
   boolean b = ((i >= ‘0′) && (i <= ‘9′))
     || ((i >= ‘A’) && (i <= ‘Z’)) || ((i >= ‘a’) && (i <= ‘z’));

   dontNeedEncoding[i] = b;
  }

  dontNeedEncoding[’ ‘] = true;
  dontNeedEncoding[’-'] = true;
  dontNeedEncoding[’_'] = true;
  dontNeedEncoding[’.'] = true;
  dontNeedEncoding[’*'] = true;
 }

 public static String encode(String s) {

  boolean wroteUnencodedChar = false;

  StringBuffer writer = new StringBuffer();

  StringBuffer out = new StringBuffer(s.length());

  for (int i = 0; i < s.length(); i++) {
   char c = s.charAt(i);

   if ((c < 256) && dontNeedEncoding[c]) {
    if (c == ‘ ‘) {
     c = ‘+’;
    }

    out.append((char) c);
    wroteUnencodedChar = true;
   } else {
    try {
     if (wroteUnencodedChar) {
      writer = new StringBuffer();
      wroteUnencodedChar = false;
     }

     writer.append(c);

     if (c >= 0xD800 && c <= 0xDBFF) {
      if ((i + 1) < s.length()) {
       int d = (int) (s.charAt(i + 1));

       if (d >= 0xDC00 && d <= 0xDFFF) {
        writer.append(d);
        i++;
       }
      }
     }

    } catch (Exception e) {
     writer = new StringBuffer();
     continue;
    }

    String str = writer.toString();

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    DataOutputStream dos = new DataOutputStream(baos);
    try {
     dos.writeUTF(str);
     dos.flush();
    } catch (Exception e) {
     e.printStackTrace();
    }

    byte[] temp = baos.toByteArray();
    byte[] ba = new byte[temp.length - 2];
    for (int ix = 0; ix < ba.length; ix++) {
     ba[ix] = temp[ix + 2];
    }

    for (int j = 0; j < ba.length; j++) {
     out.append(’%’);

     char ch = forDigit((ba[j] >> 4) & 0xF, 16);
     out.append(ch);

     ch = forDigit(ba[j] & 0xF, 16);
     out.append(ch);
    }

    writer = new StringBuffer();
    try {
     dos.close();
     baos.close();
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  }

  return out.toString();
 }

 private static char forDigit(int digit, int radix) {
  if ((digit >= radix) || (digit < 0)) {
   return ‘0′;
  }
  if (digit < 10) {
   return (char) (’0′ + digit);
  }
  return (char) (’A’ + digit – 10);
 }
}
转：http://blog.csdn.net/hunhun1981/archive/2007/09/26/1801224.aspx

]]> http://www.javagg.com/archives/815/feed 0 motionWelder动作编辑器封装使用 http://www.javagg.com/archives/805 http://www.javagg.com/archives/805#comments Fri, 09 Jul 2010 08:12:11 +0000 纯净水 http://www.javagg.com/?p=805 motionWelder是一位印度先生写的动作编辑器.曾经使用时向作者提出过一些BUG.人家都修改了.可谓是好心人啊.现在这软件也越来越强大了.

下面是我使用中的一些封装..

他有两种方式一种是MSimpleAnimationPlayer.另一种是implements MSprite.前一种是简单动画.后一种自己实现MSprite接口.可能扩展

比如MSimpleAnimationPlayer.我将成封装成Simple_Animation类

package pupaClan;
//简单动画类

import javax.microedition.lcdui.Graphics;

import mgo.common.Gamedata;

import com.studio.motionwelder.MSimpleAnimationPlayer;
import com.studio.motionwelder.MSpriteData;
import com.studio.motionwelder.MSpriteLoader;

public class Simple_Animation {
 public pupaClan_canvas canvas;
 public byte animation_Id;
 public final static byte loop_Once=-1;//一次
 public final static byte loop_While=0;//无限
 MSpriteData AnimationData=null;
    MSimpleAnimationPlayer  player=null;
    //构造方法
    public Simple_Animation(pupaClan_canvas canvas,String path,int animation_Id,int spriteX,int spriteY,boolean splitImageClips,int loopOffset){
  try {
   this.canvas=canvas;
   this.animation_Id=(byte) animation_Id;
   AnimationData=MSpriteLoader.loadMSprite(path,splitImageClips,ResourceLoader.getInstance());
   player = new MSimpleAnimationPlayer(AnimationData,spriteX,spriteY);
   player.setAnimation(this.animation_Id);
   player.setLoopOffset(loopOffset);
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
    public void run(){//逻辑
     player.update();
    }
    public int getAnimation(){//得到当前动画
    return player.getAnimation();
   }
   public int getCurrentFrame(){//得到当前动画桢
    return player.getCurrentFrame();
   }
    public boolean end(){//是否结束
     return (player.getCurrentFrame()==(player.getFrameCount()-1));
    }
    public void paint(Graphics g){//绘制
  g.setClip(0, 0, Gamedata.width, Gamedata.height);
  player.drawFrame(g);
 }
}
简单的动画就可以用他来生成一个.比如

startup_Flash=new Simple_Animation(this,”/anu/startup/pupastartup.anu”,0, 88, 190,false,Simple_Animation.loop_Once);

第一个参数是把CANVAS画布.第二个是用motionwelder生成的anu文件.第三个表示动画中的第几个(因为我的动画有好几个).第四,五个是坐标.第六个表示此动画要不要旋转.第7个是只播放一次.

第二种动画是implements MSprite实现的.

下面是我RPG游戏中一个实例

package pupaClan;
//战斗怪类
import javax.microedition.lcdui.Graphics;
import com.studio.motionwelder.MPlayer;
import com.studio.motionwelder.MSprite;
import com.studio.motionwelder.MSpriteAnimationPlayer;
import com.studio.motionwelder.MSpriteData;
import com.studio.motionwelder.MSpriteLoader;
import mgo.common.Gamedata;
import mgo.common.Obj;
import mgo.common.Timer;
import mgo.common.Tools;
import mgo.common.MediaPlayer;
public class Monster extends Obj implements MSprite{
 public pupaClan_canvas canvas;
 /***Direction***/
 public static final byte DIR_RIGHT = 0;
 public static final byte DIR_LEFT = 1;
 /** Sprite */
 public  MPlayer player;
 private MSpriteData spriteData;
 public int hp,max_hp;
 public int attack;
 public int recovery;
 public int exp;
 public int coin;
 public int level;
 public String name;
    //密锋动画初始化X偏移量
 public final static int Bee_Animation_OPP_X=18;
    //密锋动画初始化Y最大偏移量
// public final static int Bee_Animation_MAX_OPP_Y=39;
    //蜘蛛动画初始化X偏移量
 public final static int Spider_Animation_OPP_X=14;
    //蜘蛛动画初始化Y最大偏移量
// public final static int Spider_Animation_MAX_OPP_Y=25;
    //兔子动画初始化X偏移量
 public final static int Coney_Animation_OPP_X=12;
    //兔子动画初始化Y最大偏移量
// public final static int Coney_Animation_MAX_OPP_Y=24;
    //野鹿动画初始化X偏移量
 public final static int Deer_Animation_OPP_X=14;
    //野鹿动画初始化Y最大偏移量
// public final static int Deer_Animation_MAX_OPP_Y=38;
    //毒蜘蛛动画初始化X偏移量
 public final static int ToxinSpider_Animation_OPP_X=21;
    //毒蜘蛛动画初始化Y最大偏移量
// public final static int ToxinSpider_Animation_MAX_OPP_Y=49;
    //灰鹿动画初始化X偏移量
 public final static int BlackDeer_Animation_OPP_X=16;
    //灰鹿动画初始化Y最大偏移量
// public final static int BlackDeer_Animation_MAX_OPP_Y=51;
    //蛇动画初始化X偏移量
 public final static int Snake_Animation_OPP_X=16;
    //蛇动画初始化Y最大偏移量
// public final static int Snake_Animation_MAX_OPP_Y=28;
    //野狼动画初始化X偏移量
 public final static int Wolf_Animation_OPP_X=23;
    //野狼动画初始化Y最大偏移量
// public final static int Wolf_Animation_MAX_OPP_Y=28;
    //鹰动画初始化X偏移量
// public final static int Eagle_Animation_OPP_X=14;
    //鹰动画初始化Y最大偏移量
// public final static int Eagle_Animation_MAX_OPP_Y=40;
    //食人花初始化X偏移量
 public final static int Flower_Animation_OPP_X=17;
    //食人花初始化Y最大偏移量
// public final static int Flower_Animation_MAX_OPP_Y=40;
    //穿山甲初始化X偏移量
 public final static int Pangolin_Animation_OPP_X=29;
    //穿山甲初始化Y最大偏移量
// public final static int Pangolin_Animation_MAX_OPP_Y=23;
    //树怪初始化X偏移量
   //public final static int TreeMonster_Animation_OPP_X=19;
    //树怪初始化Y最大偏移量
// public final static int TreeMonster_Animation_MAX_OPP_Y=38;
    //雕初始化X偏移量
 public final static int Vulture_Animation_OPP_X=25;
    //雕初始化Y最大偏移量
// public final static int Vulture_Animation_MAX_OPP_Y=54;
    //霸王花初始化X偏移量
 public final static int OverloadFlower_Animation_OPP_X=22;
    //霸王花初始化Y最大偏移量
// public final static int OverloadFlower_Animation_MAX_OPP_Y=45;
    //眼镜蛇王初始化X偏移量
 public final static int Cobra_Animation_OPP_X=21;
    //眼镜蛇王初始化Y最大偏移量
// public final static int Cobra_Animation_MAX_OPP_Y=34;
    //千年树妖初始化X偏移量
 //public final static int KiloTreeMonster_Animation_OPP_X=19;
    //千年树妖初始化Y最大偏移量
// public final static int KiloTreeMonster_Animation_MAX_OPP_Y=51;
    //血狼初始化X偏移量
 public final static int BloodWolf_Animation_OPP_X=25;
    //血狼初始化Y最大偏移量
// public final static int BloodWolf_Animation_MAX_OPP_Y=33;
 
    //人熊初始化X偏移量
 public final static int Bear_Animation_OPP_X=27;
    //人熊初始化Y最大偏移量
// public final static int Bear_Animation_MAX_OPP_Y=65;
    //大狼初始化X偏移量
 public final static int BigWolf_Animation_OPP_X=17;
    //大狼初始化Y最大偏移量
// public final static int BigWolf_Animation_MAX_OPP_Y=48;
    //剑齿虎初始化X偏移量
 public final static int Tiger_Animation_OPP_X=43;
    //剑齿虎初始化Y最大偏移量
// public final static int Tiger_Animation_MAX_OPP_Y=51;
    /** Animations */
 public final static byte MON_SLEEP=0;//站着不动
 public final static byte MON_KILL1=1;//普通攻击
 public final static byte MON_INJURED1=2;//被攻击1,黄色闪光（小）
 public final static byte MON_DIE=3;//死亡
 public final static byte MON_KILL2=4;//非普通攻击,BOSS用
 public final static byte MON_KILL3=5;//非普通攻击,BOSS大狼用
 
    private int animation;
    public boolean 怪物操作;
    public Timer timer=new Timer();
    public Monster(pupaClan_canvas canvas,byte type,int spriteX,int spriteY){
  try{
   this.canvas=canvas;
   this.type=type;
   String path = null;
   int Animation_OPP_X = 0;
   switch(this.type){
       case 蜜蜂:
        setLevel(Tools.getRand(1,3));
        Animation_OPP_X=Bee_Animation_OPP_X;
         path=”/anu/monster/Bee.anu”;
         name=”蜜蜂”;
    break;
       case 蜘蛛:
        setLevel(Tools.getRand(1,3));
        Animation_OPP_X=Spider_Animation_OPP_X;
        path=”/anu/monster/Spider.anu”;
        name=”蜘蛛”;
       break;
       case 兔子:
        setLevel(Tools.getRand(3,7));
        Animation_OPP_X=Coney_Animation_OPP_X;
        path=”/anu/monster/Coney.anu”;
        name=”兔子”;
       break;
       case 野鹿:
        setLevel(Tools.getRand(5,10));
        Animation_OPP_X=Deer_Animation_OPP_X;
        path=”/anu/monster/Deer.anu”;
        name=”野鹿”;
       break;
       case 灰兔:
        setLevel(Tools.getRand(10,13));
        Animation_OPP_X=Coney_Animation_OPP_X;
        path=”/anu/monster/hui-Coney.anu”;
        name=”灰兔”;
       break;
       case 毒蜘蛛:
        setLevel(Tools.getRand(11,15));
        Animation_OPP_X=ToxinSpider_Animation_OPP_X;
        path=”/anu/monster/ToxinSpider.anu”;
        name=”毒蜘蛛”;
       break;
       case 蜂王:
        setLevel(Tools.getRand(15,20));
        Animation_OPP_X=Bee_Animation_OPP_X;
         path=”/anu/monster/king-Bee.anu”;
         name=”蜂王”;
       break;
       case 灰鹿:
        setLevel(Tools.getRand(18,22));
        Animation_OPP_X=BlackDeer_Animation_OPP_X;
         path=”/anu/monster/BlackDeer.anu”;
         name=”灰鹿”;
       break;
       case 蛇:
        setLevel(Tools.getRand(20,25));
        Animation_OPP_X=Snake_Animation_OPP_X;
         path=”/anu/monster/Snake.anu”;
         name=”蛇”;
       break;
       case 野狼:
        setLevel(Tools.getRand(22,25));
        Animation_OPP_X=Wolf_Animation_OPP_X;
         path=”/anu/monster/Wolf.anu”;
         name=”野狼”;
       break;
       case 青狼:
        setLevel(Tools.getRand(38,40));
        Animation_OPP_X=Wolf_Animation_OPP_X;
         path=”/anu/monster/Wolf1.anu”;
         name=”青狼”;
       break;
       case 黑鹿:
        setLevel(Tools.getRand(25,28));
           Animation_OPP_X=BlackDeer_Animation_OPP_X;
            path=”/anu/monster/HaDeer.anu”;
            name=”黑鹿”;
          break;
       case 食人花:
        setLevel(Tools.getRand(28,32));
           Animation_OPP_X=Flower_Animation_OPP_X;
            path=”/anu/monster/Flower.anu”;
            name=”食人花”;
          break;
       case 穿山甲:
        setLevel(Tools.getRand(30,35));
           Animation_OPP_X=Pangolin_Animation_OPP_X;
            path=”/anu/monster/Pangolin.anu”;
            name=”穿山甲”;
       break;
       case 穿山甲王:
        setLevel(Tools.getRand(43,46));
           Animation_OPP_X=Pangolin_Animation_OPP_X;
            path=”/anu/monster/Pangolin1.anu”;
            name=”穿山甲王”;
       break;
       case 雕:
        setLevel(Tools.getRand(35,40));
           Animation_OPP_X=Vulture_Animation_OPP_X;
            path=”/anu/monster/Vulture.anu”;
            name=”雕”;
       break;
       case 霸王花:
        setLevel(Tools.getRand(40,45));
              Animation_OPP_X=OverloadFlower_Animation_OPP_X;
               path=”/anu/monster/OverloadFlower.anu”;
               name=”霸王花”;
          break;
       case 眼镜蛇王:
        setLevel(Tools.getRand(42,47));
              Animation_OPP_X=Cobra_Animation_OPP_X;
               path=”/anu/monster/Cobra.anu”;
               name=”眼镜蛇王”;
          break;
       case 血狼:
        setLevel(Tools.getRand(45,50));
                 Animation_OPP_X=BloodWolf_Animation_OPP_X;
                  path=”/anu/monster/BloodWolf.anu”;
                  name=”血狼”;
             break;
       case 人熊:
        hp=max_hp=480;attack=95;recovery=50;exp=632;coin=500;
                 Animation_OPP_X=Bear_Animation_OPP_X;
                  path=”/anu/monster/Bear.anu”;
                  name=”人熊”;
             break;
       case 大狼:
        hp=max_hp=850;attack=208;recovery=108;exp=2571;coin=1280;
                 Animation_OPP_X=BigWolf_Animation_OPP_X;
                  path=”/anu/monster/BigWolf.anu”;
                  name=”大狼”;
             break;
       case 剑齿虎:
        hp=max_hp=1120;attack=309;recovery=160;exp=4720;coin=2000;
                 Animation_OPP_X=Tiger_Animation_OPP_X;
                  path=”/anu/monster/Tiger.anu”;
                  name=”剑齿虎”;
             break;
   }
   this.spriteX=Animation_OPP_X+spriteX;
   this.spriteY=spriteY;
   spriteData=MSpriteLoader.loadMSprite(path,false,ResourceLoader.getInstance());
   player = new MSpriteAnimationPlayer(spriteData,this);
   setAnimation(MON_SLEEP);
   direction = DIR_RIGHT;
  }catch (Exception e){
   e.printStackTrace();
  }
 }
 public void run(){
  if(Obj.isMonsterBoss(this.type)){//BOSS
   switch(this.type){
       case Obj.人熊:
       case Obj.剑齿虎:
        switch (animation) {
         case MON_SLEEP:
          if(canvas.battle_hero.主角操作完成 & timer.arrive_Time(canvas.battle_hero.延迟时间)){
           if(hp<(max_hp>>1)){//自身生命少于一半
               setAnimation(Tools.getOnlyRand(MON_KILL1, MON_KILL2));
              }else{
               setAnimation(MON_KILL1);
              }
          }
         break;
            case MON_KILL1:
             if(!timer.arrive_Time(canvas.battle_hero.延迟时间))return;
             if(getCurrentFrame()==5)canvas.battle_hero.setAnimation(BattleHero.HERO_INJURED1);
            break;
            case MON_KILL2:
             if(!timer.arrive_Time(canvas.battle_hero.延迟时间))return;
             if(getCurrentFrame()==6)canvas.battle_hero.setAnimation(BattleHero.HERO_INJURED1);
            break;
        }
    break;
       case Obj.大狼:
        switch (animation) {
         case MON_SLEEP:
          if(canvas.battle_hero.主角操作完成 & timer.arrive_Time(canvas.battle_hero.延迟时间)){
           if(hp<(max_hp>>1)){//自身生命少于一半
               setAnimation(Tools.getOnlyRand(MON_KILL1, MON_KILL2, MON_KILL3));
              }else{
               setAnimation(MON_KILL1);
              }
          }
         break;
            case MON_KILL1:
             if(!timer.arrive_Time(canvas.battle_hero.延迟时间))return;
             if(getCurrentFrame()==5)canvas.battle_hero.setAnimation(BattleHero.HERO_INJURED1);
            break;
            case MON_KILL2:
            case MON_KILL3:
             if(!timer.arrive_Time(canvas.battle_hero.延迟时间))return;
             if(getCurrentFrame()==5)canvas.battle_hero.setAnimation(BattleHero.HERO_INJURED1);
            break;
        }
    break;
   }
  }else{//小怪
   switch (animation){
       case MON_SLEEP:
        if(canvas.battle_hero.主角操作完成 & timer.arrive_Time(canvas.battle_hero.延迟时间))setAnimation(MON_KILL1);
       break;
          case MON_KILL1:
           if(!timer.arrive_Time(canvas.battle_hero.延迟时间))return;
           if(getCurrentFrame()==4)canvas.battle_hero.setAnimation(BattleHero.HERO_INJURED1);
          break;
      }
  }
  player.update();
  }
 public void endOfAnimation(){
        switch (animation){
              case MON_KILL1:
              case MON_KILL2:
              case MON_KILL3:
               setAnimation(MON_SLEEP);
               canvas.battle_hero.主角操作完成=false;
           break;
        case MON_INJURED1://普通攻击
         check_Die(canvas.common_hero.attack+(canvas.返回主角身上装备(Equip.攻击装备)!=null?((Equip)canvas.返回主角身上装备(Equip.攻击装备)).getAttack():0)-recovery);
        break;
        case MON_DIE:
         if(!canvas.battle_Complete){
           canvas.mediaPlayer.playSound(“/sound/battlesuccess.mid”, MediaPlayer.play_Once);//播放音乐
          checkTaskFromBattle();//更新任务
          /****增加主角经验,金币,检测主角是否升级****/
          canvas.common_hero.coin=canvas.common_hero.coin+coin;
          canvas.common_hero.exp=canvas.common_hero.exp+exp;
          canvas.hero_IsUpgrade=canvas.common_hero.checkLevel();
          canvas.battle_Complete=true;
          canvas.cursor_y=0;
          canvas.backup_time=System.currentTimeMillis();
          canvas.timer.init_Time();
         }
        break; 
  }
  }
 private void check_Die(int injure){//根据injure值检测怪物是否死亡
  if(injure<0)injure=0;
        hp=hp-injure;
        if(hp<0)hp=0;
        if(hp>0){//怪没有死
         if(Obj.isMonsterBoss(this.type)){//BOSS
       switch(this.type){
           case Obj.人熊:
           case Obj.剑齿虎:
            if(hp<(max_hp>>1)){//自身生命少于一半
             setAnimation(Tools.getOnlyRand(MON_KILL1, MON_KILL2));
            }else{
             setAnimation(MON_KILL1);
            }
            canvas.主角操作完毕并设置延迟时间(700l);
        break;
           case Obj.大狼:
            if(hp<(max_hp>>1)){//自身生命少于一半
             setAnimation(Tools.getOnlyRand(MON_KILL1, MON_KILL2, MON_KILL3));
            }else{
             setAnimation(MON_KILL1);
            }
            canvas.主角操作完毕并设置延迟时间(700l);
           break;
       }
      }else{//小怪
       setAnimation(MON_KILL1);
       canvas.主角操作完毕并设置延迟时间(700l);
      }
     }else setAnimation(MON_DIE);//怪死亡了
    }
 public void paint(Graphics g){//绘制
  g.setClip(0, 0, Gamedata.width, Gamedata.height);
  player.drawFrame(g);
 }
 public int getSpriteDrawX(){
  return getSpriteX();
 }
 
 public int getSpriteDrawY(){
  return getSpriteY();
 }
    byte orientation;
 public byte getSpriteOrientation(){
  return (byte)direction;
 }
 public void updateSpritePosition(int incX,int incY){
  spriteX+=incX;
  spriteY+=incY;

 }
  public boolean end(){
     return (player.getCurrentFrame()==(player.getFrameCount()-1));
  }
 public int getAnimation(){
  return player.getAnimation();
 }
 public int getCurrentFrame(){
  return player.getCurrentFrame();
 }
 public void setAnimation(int animation){
   switch (animation) {
      case MON_SLEEP:
      player.setAnimation(MON_SLEEP);
      player.setLoopOffset(0);
   break;
      default:
       player.setAnimation(animation);
      player.setLoopOffset(-1);
      break;
      }
         this.animation = animation; 
 }
  public void setLevel(int level){//设置怪物级别
  this.level=level;
  switch(this.level){
      case 1:
       hp=max_hp=20;attack=5;recovery=2;exp=Tools.getRand(8,10);coin=Tools.getRand(1,10);
   break;
      case 2:
       hp=max_hp=23;attack=6;recovery=3;exp=Tools.getRand(8,10);coin=Tools.getRand(1,10);
   break;
      case 3:
       hp=max_hp=26;attack=8;recovery=4;exp=Tools.getRand(8,10);coin=Tools.getRand(1,10);
   break;
      case 4:
       hp=max_hp=30;attack=9;recovery=4;exp=Tools.getRand(8,10);coin=Tools.getRand(1,10);
   break;
      case 5:
       hp=max_hp=34;attack=11;recovery=5;exp=Tools.getRand(8,10);coin=Tools.getRand(1,10);
   break;
      case 6:
       hp=max_hp=39;attack=13;recovery=6;exp=Tools.getRand(34,40);coin=Tools.getRand(14,40);
   break;
      case 7:
       hp=max_hp=44;attack=15;recovery=7;exp=Tools.getRand(34,40);coin=Tools.getRand(14,40);
   break;
      case 8:
       hp=max_hp=50;attack=18;recovery=9;exp=Tools.getRand(34,40);coin=Tools.getRand(14,40);
   break;
      case 9:
       hp=max_hp=56;attack=20;recovery=10;exp=Tools.getRand(34,40);coin=Tools.getRand(14,40);
   break;
      case 10:
       hp=max_hp=63;attack=23;recovery=11;exp=Tools.getRand(34,40);coin=Tools.getRand(14,40);
   break;
      case 11:
       hp=max_hp=70;attack=26;recovery=13;exp=Tools.getRand(94,110);coin=Tools.getRand(48,90);
   break;
      case 12:
       hp=max_hp=78;attack=29;recovery=14;exp=Tools.getRand(94,110);coin=Tools.getRand(48,90);
   break;
      case 13:
       hp=max_hp=86;attack=32;recovery=16;exp=Tools.getRand(94,110);coin=Tools.getRand(48,90);
   break;
      case 14:
       hp=max_hp=95;attack=36;recovery=18;exp=Tools.getRand(94,110);coin=Tools.getRand(48,90);
   break;
      case 15:
       hp=max_hp=104;attack=40;recovery=20;exp=Tools.getRand(94,110);coin=Tools.getRand(48,90);
   break;
      case 16:
       hp=max_hp=113;attack=44;recovery=22;exp=Tools.getRand(171,200);coin=Tools.getRand(102,160);
   break;
      case 17:
       hp=max_hp=123;attack=48;recovery=24;exp=Tools.getRand(171,200);coin=Tools.getRand(102,160);
   break;
      case 18:
       hp=max_hp=134;attack=52;recovery=26;exp=Tools.getRand(171,200);coin=Tools.getRand(102,160);
   break;
      case 19:
       hp=max_hp=144;attack=57;recovery=28;exp=Tools.getRand(171,200);coin=Tools.getRand(102,160);
   break;
      case 20:
       hp=max_hp=156;attack=62;recovery=31;exp=Tools.getRand(171,200);coin=Tools.getRand(102,160);
   break;
  
      case 21:
       hp=max_hp=168;attack=67;recovery=33;exp=Tools.getRand(300,350);coin=Tools.getRand(176,250);
   break;
      case 22:
       hp=max_hp=180;attack=72;recovery=36;exp=Tools.getRand(300,350);coin=Tools.getRand(176,250);
   break;
      case 23:
       hp=max_hp=193;attack=77;recovery=38;exp=Tools.getRand(300,350);coin=Tools.getRand(176,250);
   break;
      case 24:
       hp=max_hp=206;attack=83;recovery=41;exp=Tools.getRand(300,350);coin=Tools.getRand(176,250);
   break;
      case 25:
       hp=max_hp=220;attack=89;recovery=44;exp=Tools.getRand(300,350);coin=Tools.getRand(176,250);
   break;
      case 26:
       hp=max_hp=234;attack=95;recovery=47;exp=Tools.getRand(462,540);coin=Tools.getRand(270,360);
   break;
      case 27:
       hp=max_hp=248;attack=101;recovery=50;exp=Tools.getRand(462,540);coin=Tools.getRand(270,360);
   break;
      case 28:
       hp=max_hp=263;attack=107;recovery=53;exp=Tools.getRand(462,540);coin=Tools.getRand(270,360);
   break;
      case 29:
       hp=max_hp=279;attack=114;recovery=57;exp=Tools.getRand(462,540);coin=Tools.getRand(270,360);
   break;
      case 30:
       hp=max_hp=295;attack=120;recovery=60;exp=Tools.getRand(462,540);coin=Tools.getRand(270,360);
   break;
      case 31:
       hp=max_hp=311;attack=127;recovery=63;exp=Tools.getRand(651,760);coin=Tools.getRand(384,490);
   break;
      case 32:
       hp=max_hp=328;attack=135;recovery=67;exp=Tools.getRand(651,760);coin=Tools.getRand(384,490);
   break;
      case 33:
       hp=max_hp=346;attack=142;recovery=71;exp=Tools.getRand(651,760);coin=Tools.getRand(384,490);
   break;
      case 34:
       hp=max_hp=363;attack=149;recovery=74;exp=Tools.getRand(651,760);coin=Tools.getRand(384,490);
   break;
      case 35:
       hp=max_hp=382;attack=157;recovery=78;exp=Tools.getRand(651,760);coin=Tools.getRand(384,490);
   break;
      case 36:
       hp=max_hp=401;attack=165;recovery=82;exp=Tools.getRand(857,1000);coin=Tools.getRand(518,640);
   break;
      case 37:
       hp=max_hp=420;attack=173;recovery=86;exp=Tools.getRand(857,1000);coin=Tools.getRand(518,640);
   break;
      case 38:
       hp=max_hp=440;attack=182;recovery=91;exp=Tools.getRand(857,1000);coin=Tools.getRand(518,640);
   break;
      case 39:
       hp=max_hp=460;attack=190;recovery=95;exp=Tools.getRand(857,1000);coin=Tools.getRand(518,640);
   break;
      case 40:
       hp=max_hp=480;attack=199;recovery=99;exp=Tools.getRand(857,1000);coin=Tools.getRand(518,640);
   break;
      case 41:
       hp=max_hp=501;attack=208;recovery=104;exp=Tools.getRand(1114,1300);coin=Tools.getRand(672,810);
   break;
      case 42:
       hp=max_hp=523;attack=217;recovery=108;exp=Tools.getRand(1114,1300);coin=Tools.getRand(672,810);
   break;
      case 43:
       hp=max_hp=545;attack=227;recovery=113;exp=Tools.getRand(11114,1300);coin=Tools.getRand(672,810);
   break;
      case 44:
       hp=max_hp=567;attack=236;recovery=118;exp=Tools.getRand(11114,1300);coin=Tools.getRand(672,810);
   break;
      case 45:
       hp=max_hp=590;attack=246;recovery=123;exp=Tools.getRand(11114,1300);coin=Tools.getRand(672,810);
   break;
      case 46:
       hp=max_hp=614;attack=256;recovery=128;exp=Tools.getRand(1285,1500);coin=Tools.getRand(846,1000);
   break;
      case 47:
       hp=max_hp=638;attack=266;recovery=133;exp=Tools.getRand(1285,1500);coin=Tools.getRand(846,1000);
   break;
      case 48:
       hp=max_hp=662;attack=276;recovery=138;exp=Tools.getRand(1285,1500);coin=Tools.getRand(846,1000);
   break;
      case 49:
       hp=max_hp=687;attack=287;recovery=143;exp=Tools.getRand(1285,1500);coin=Tools.getRand(846,1000);
   break;
      case 50:
       hp=max_hp=712;attack=298;recovery=149;exp=Tools.getRand(1285,1500);coin=Tools.getRand(846,1000);
   break;
     }
 }
 public void checkTaskFromBattle(){//战斗胜利,更新任务中各个数量
   for(int i=0;i<canvas.taskVector.size();i++){
    Task t=(Task) canvas.taskVector.elementAt(i);
    if(t.task_Name.equals(Task.task_Name5)&this.type==Obj.蜜蜂){
     if(canvas.common_hero.杀死蜜蜂数量<20)canvas.common_hero.杀死蜜蜂数量++;
     break;
    }
    if(t.task_Name.equals(Task.task_Name6)&this.type==Obj.毒蜘蛛){
     if(canvas.common_hero.杀死毒蜘蛛数量<30)canvas.common_hero.杀死毒蜘蛛数量++;
     break;
    }
    if(t.task_Name.equals(Task.task_Name7)&this.type==Obj.食人花){
     if(canvas.common_hero.杀死食人花数量<30)canvas.common_hero.杀死食人花数量++;
     break;
    }
    if(t.task_Name.equals(Task.task_Name8)){
     switch(this.type){
         case Obj.霸王花:
          if(canvas.common_hero.杀死霸王花数量<10)canvas.common_hero.杀死霸王花数量++;
      break;
         case Obj.眼镜蛇王:
          if(canvas.common_hero.杀死眼镜蛇王数量<10)canvas.common_hero.杀死眼镜蛇王数量++;
         break;
         case Obj.穿山甲王:
          if(canvas.common_hero.杀死穿山甲王数量<10)canvas.common_hero.杀死穿山甲王数量++;
         break;
         case Obj.血狼:
          if(canvas.common_hero.杀死血狼数量<10)canvas.common_hero.杀死血狼数量++;
         break;
     }
     break;
    }
   }
 }
}

此类是怪的行为类.

endOfAnimation()在一个动画结束时会调用.

updateSpritePosition()是更新坐标.检测

getSpriteOrientation()得到方向

setAnimation()设置新的动画

end()检查是否播放结束

getSpriteDrawX()得到绘制X.

getSpriteDrawY()得到绘制Y.

无论用哪种方式.都要自己实现ResourceLoader类

ResourceLoader类就是你的动画需要指定创建哪些图片资源

有loadImage和loadImageClip二种方法

]]> http://www.javagg.com/archives/805/feed 0 手机游戏动作编辑器MotionWelder–编写程序 http://www.javagg.com/archives/800 http://www.javagg.com/archives/800#comments Thu, 08 Jul 2010 06:49:01 +0000 纯净水 http://www.javagg.com/?p=800 开发环境：Eclipse+EclipseMe （Eclipse3.4版本以上使用EclipseMe时在添加第三方库常常会出现classnotfound异常，可使用mtj代替EclipseME，或使用低一些的Eclipse版本）
1、新建J2ME工程，导入MotionWelder的J2ME库（在该程序下载包里J2ME 的lib目录里的motionwelder.jar）
       右键工程–>Build Path –>Add external archives… —>选择motionwelder.jar打开，即可导入完毕。
2、把导出的动作数据文件拷到工程的资源目录，导入动作数据文件
/*
spriteName 动作数据文件
splitImageClips 内存加载图片的方式，如果为false则加载完整的图片（图片没有切片），true则加载切片的图片
imageloader  加载动作所需图片的类
*/
MSpriteData animationData = MSpriteLoader.loadMSprite(java.lang.String spriteName, boolean splitImageClips, MSpriteImageLoader imageloader)
3、加载动作图片
interface MSpriteImageLoader：
splitImageClips = false  - 加载完整的图片
           Image[]  loadImage(spriteName,imageId,orientationUsedInStudio);

splitImageClips = true – 加载图片切片
          Image[] loadImageClip(String spriteName,int imageId,int x,int y,int w,int h,int orientationUsedInStudio);

-spriteName
         – 动作数据文件的名字
-orientationUsedInStudio
        -使用了的翻转类型,
               MSprite.ORIENTATION_NONE                         – 无翻转
               MSprite.ORIENTATION_FLIP_H                      - 水平翻转
               MSprite.ORIENTATION_FLIP_V                      - 垂直翻转
               MSprite.ORIENTATION_FLIP_BOTH_H_V   – 水平和垂直翻转
- imageId
         – 图片id，即动作所使用到的图片
-x,y,w,h      
       -切片在图片中的坐标（x，y，宽，高）.
Image[3]
       Image[0] =无翻转图片
       Image[1] = 水平翻转图片      // 如果没有为null
       Image[2] = 垂直翻转图片         // 如果没有为null
4、播放动作
/*动作列表*/
public static int ANIM_STAND = 0;
public static int ANIM_RUN = 1;

/* 创建动作播放器 */
MSimpleAnimationPlayer player = new MSimpleAnimationPlayer(MSpriteData spriteData, int spriteX, int spriteY);
或
MSpriteAnimationPlayer player = new MSpriteAnimationPlayer(MSpriteData spriteData, MSprite sprite);
两个的区别在于：正如名字一样MSpriteAnimationPlayer提供的一个简单的播放器，它在处理end of animation时是仅停止播放，不能更好地拓展。如果需要灵巧地控制各个动画的切换最好使用MSpriteAnimationPlayer。

/*设置当前的播放动作*/
player.setAnimation(ANIM_STAND);
player.setLoopOffset(-1);           // 播放一次..
player.setLoopOffset(0);            // 从第一帧到帧尾循环播放
player.setLoopOffset(2);           // 从第二帧到帧尾循环播放

/* 循环调用这里，更新和绘制动作*/
player.update();
player.drawFrame(g);

例子：使用第一节的数据文件，当我们按数字键5或者中键的时候施放这个向下攻击的动作。主要代码如下：
主屏幕   GameScreen.java
import javax.microedition.lcdui.Canvas;
import javax.microedition.lcdui.Graphics;
public class GameScreen extends Canvas implements Runnable {
private GameSprite gameSprite;//游戏精灵
private static final int KEY_FIRE=-5;//键盘中键
public static boolean isHit = false;//是否发动攻击
public GameScreen() {
  gameSprite = new GameSprite();//实例化游戏精灵
  Thread t = new Thread(this);//创建线程
  t.start();//启动线程
}
protected void paint(Graphics g) {
  g.setColor(0xffffffff);
  g.fillRect(0, 0, getWidth(), getHeight());//清屏
  gameSprite.paint(g);//绘制精灵
}
public void run() {
  try {
   long time;
   while (true) {
    time = System.currentTimeMillis();
    //重绘
    repaint();
    serviceRepaints();
    if (isHit) {//如果发动攻击
     gameSprite.update();//更新精灵
    }
    long timeTakenForPainting = System.currentTimeMillis() – time;
    if (timeTakenForPainting < 100) {
     Thread.sleep(100 – timeTakenForPainting);
    }
   }
  } catch (Exception e) {
   System.out.println(“Error ” + e);
  }
}
protected void keyPressed(int key) {
  if (key == Canvas.KEY_NUM5 || key == KEY_FIRE) {
   isHit = true;//按数字键5或中键攻击
  }
}
protected void keyReleased(int key) {
}
}

游戏精灵  GameSprite.java
import javax.microedition.lcdui.Graphics;
import com.studio.motionwelder.MPlayer;
import com.studio.motionwelder.MSprite;
import com.studio.motionwelder.MSpriteAnimationPlayer;
import com.studio.motionwelder.MSpriteData;
import com.studio.motionwelder.MSpriteLoader;
public class GameSprite implements MSprite {
private MSpriteData spriteData;
private MPlayer player;
private int animation;
private static final int DOWN_HIT = 0;
int spriteX = 100;//精灵坐标
int spriteY = 175;
public GameSprite() {
  try {
   loadResource();//加载资源
  } catch (Exception e) {
   e.printStackTrace();
  }
  player = new MSpriteAnimationPlayer(spriteData, this);//创建播放器
  this.setAnimation(DOWN_HIT);//设置当前动画ID
}
private void setAnimation(int animation) {//设置动画ID
  switch (animation) {
  case DOWN_HIT:
   player.setAnimation(DOWN_HIT);
   break;
  }
  this.animation = animation;
}
private void loadResource() throws Exception {
  spriteData = MSpriteLoader.loadMSprite(“/SwordSprite.anu”, true,
    ResourceLoader.getInstance());//加载数据文件
}
public void update() {
  switch (animation) {
  case DOWN_HIT:
   player.setLoopOffset(-1);//设置仅播放一次
   break;
  }
  player.update();//下一帧
}
public void endOfAnimation() {//处理动画播放完后的方法，可以添加切换到另外的动画等等
  switch (animation) {
  case DOWN_HIT:
   player.setFrame(0);//如果播放完则设置帧为第0帧
   break;
  }
  GameScreen.isHit = false;//攻击动作完成
}
public int getSpriteDrawX() {//设置精灵的绘制坐标X
  return spriteX;
}
public int getSpriteDrawY() {//设置精灵的绘制坐标Y
  return spriteY;
}
public byte getSpriteOrientation() {//设置精灵的方向
  return 0;
}
public void updateSpritePosition(int arg0, int arg1) {
  //更新精灵的位置，比如跑动是X及Y的坐标变化
}
public void paint(Graphics g) {
  player.drawFrame(g);//绘制动作的帧
}
}

资源加载 ResourceLoader.java
import java.io.IOException;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.Sprite;
import com.studio.motionwelder.MSprite;
import com.studio.motionwelder.MSpriteImageLoader;
public class ResourceLoader implements MSpriteImageLoader {
private static ResourceLoader resLoader;// 单例
private ResourceLoader() {
}
public static ResourceLoader getInstance() {// 获取ResourceLoader的实例
  if (resLoader == null)
   resLoader = new ResourceLoader();
  return resLoader;
}
public Image[] loadImage(String spriteName, int imageId,
   int orientationUsedInStudio) {// 整图形式加载图片
  return null;
}
public Image[] loadImageClip(String spriteName, int imageId, int x, int y,
   int w, int h, int orientationUsedInStudio) {// 切片形式加载图片
  boolean doYouNeedHFlippedSpriteInYourgame = false;
  boolean doYouNeedVFlippedSpriteInYourgame = false; // 是否有旋转操作
  Image baseImage = null;
  if (imageId == 0) {
   baseImage = loadImage(“/hero.png”);
   doYouNeedHFlippedSpriteInYourgame = false;
   doYouNeedVFlippedSpriteInYourgame = false;
  }
  Image img[] = new Image[3];
  img[0] = Image.createImage(baseImage, x, y, w, h, Sprite.TRANS_NONE); // 保存无旋转的切片
  /** 如果使用了Nokia的图像操作就不要这样用，关于Nokia的操作作者在库代码里把它注释掉了 */
  if (orientationUsedInStudio == MSprite.ORIENTATION_FLIP_H
    || orientationUsedInStudio == MSprite.ORIENTATION_FLIP_BOTH_H_V
    || doYouNeedHFlippedSpriteInYourgame)
   img[1] = Image.createImage(baseImage, x, y, w, h,
     Sprite.TRANS_MIRROR); // 保存水平旋转的切片
  /** 如果使用了Nokia的图像操作就不要这样用，关于Nokia的操作作者在库代码里把它注释掉了 */
  if (orientationUsedInStudio == MSprite.ORIENTATION_FLIP_V
    || orientationUsedInStudio == MSprite.ORIENTATION_FLIP_BOTH_H_V
    || doYouNeedVFlippedSpriteInYourgame)
   img[2] = Image.createImage(baseImage, x, y, w, h,
     Sprite.TRANS_MIRROR_ROT180); // 保存垂直旋转的切片
  return img;
}
private Image loadImage(String imagePath) {
  try {
   Image img = Image.createImage(imagePath);
   return img;
  } catch (IOException e) {
   e.printStackTrace();
  }
  return null;
}
}

]]> http://www.javagg.com/archives/800/feed 0 使用动画编辑器编辑、绘制复杂的精灵动画 http://www.javagg.com/archives/778 http://www.javagg.com/archives/778#comments Fri, 14 May 2010 14:08:23 +0000 纯净水 http://www.javagg.com/?p=778 我们平时所玩的很多游戏都有着非常绚丽的动画效果，尤其是像ACT、RPG等类型的游戏，必须拥有华丽的魔法和攻击效果才能吸引玩家的眼球。本文将主要介绍如何使用OPhone API以及动画编辑器类的工具来编辑、绘制和处理精灵的动画，整个程序的运行效果如下图所示：


图1 游戏最终效果

动画原理

我们都看过动画片，看过电影，玩过游戏，里面都有各种绚丽的动画，实际上动画的绘制机制概括说来就是以一定的速度连续播放静态的图片，这样人眼就能识别出动画。一般我们人眼能够分辨的动画速度为10——20帧/秒，我们称之为FPS（Frame Per Second），低于10帧就会变得很卡，高于20就会变成快动作，因此，控制好这个数值对游戏整体的流畅度至关重要。

那么总结起来，要想在游戏中绘制动画需要具备以下几个必要元素：

1. 动画的原始图片

2.动画序列数据

3.动画刷新机制（下一帧）

常规的动画播放方法

1.实现第一步（动画的原始图片）

常规的播放2D动画方法的方法实际就是对上述过程的一个分解：在游戏中，精灵的图片经常是被放置到一张图片上，下图就是一个典型的2D游戏精灵图片：


图2 角色原始图片

2.实现第二步（设定动画序列）

有了原始图片之后，我们就可以把这些图片按照一定的尺寸进行分割，切割成的每个块我们称之为“帧”，同时为每一帧进行编号，为每帧分配唯一的索引号，索引号可以从任意数字开始，可连续也可以随机，但要注意不能有重复的索引号，分配好的索引号可参照下图所示：

表1 游戏帧序列

0 1 2 3 4 5 6 7 8 9 10 11

 

有了这个索引，我们就可以为每个动画设定动画序列了，比如，我们可以分别定义精灵的上、下、左、右行走的动画序列，每个动画的序列如下面代码所示：

final static int ACTION_UP[]={0,1,2};

    final static int ACTION_DOWN[]={6,7,8};

    final static int ACTION_LEFT[]={9,10,11};

    final static int ACTION_RIGHT[]={3,4,5}; 

    final static int ACTION_STAND[]={7};  

数组中的每个元素值就是上面表格中的数值。

3.实现第三步（切换并播放动画）
　由于所有的图片块都被放置到了一个数组中保存起来，因此有个动画数据之后，我们就可以把数据所对应的图片绘制到屏幕上了，然后，通过线程来控制一帧一帧的切换，这就是游戏中动画处理的一般过程。

 

上面这种播放动画的方式的优点是开发简单，便于切换和控制，但是也有如下的一些缺点：

　　1.存在重复的图片资源

我们可以从原始图片上看到，如果要实现精灵向下走的动画，需要使用4帧图片，但是这4帧图片中只有精灵脚步的图片存在差异，剩下的都大致相同，这就是一种图片上的浪费。而我们的手机内存目前还比较小，因此这种浪费应该是要尽量避免的。

　　2.动画数据直接存在于代码中

上面的例子中，我们直接把动画的序列以数组的形式保存到了代码中，也就是说，把对动画数据的处理交给了程序员来完成，而程序员的主要工作应该是处理游戏中的算法逻辑，因此，比较好的解决方法是把动画的处理交给美工和策划来完成。因此，上面这种方法也存在缺点。

　　3.帧图片要求规整

如果采用上面的方法绘制动画，要求每一帧必须按照指定的长度和宽度进行分割，否则就是出现绘制错误，这在一定程度上也限制了程序的灵活性。

　　4. 难易实现复杂的动画效果

由于帧的尺寸人为的被限定，同时每一个动作就必须要一帧进行显示，如果要想实现复杂的动画序列就意味着要存在大量的帧序列，而原始图片势必要随之变得很大，进而增加了对内存的占用，而在这种情况下，帧数越多，重复的内容也会随之不断增多，显然这也不适合手机这种资源有限的设备的特点。

上面说了这些缺点，那么该如何解决呢？下面就为你介绍一下目前比较流行的一种动画处理方式，也是本文的重点——使用动画编辑工具。

作者介绍

李建，乐成数字通信学院 高级讲师。层就职于国内数家SP，CP公司，具有丰富的软件、游戏开发经验。并从事多年教学工作，具有丰富的教学经验。目前主要从事OPhone、J2ME开发和教学方面的工作。

动画编辑器的原理

动画编辑器就是一种软件工具，它的作用就是通过软件对原始图片进行切割，然后在软件中把切割好的图片块拼成一帧一帧的图片，再选择相应的图片来组成动画序列，最后将数据导出以文件。

动画编辑器的使用

目前，很多的手机游戏公司都在使用动画编辑器来制作动画，而不同的公司使用的工具也不尽相同，下图为一个功能比较强大且使用很广泛的动画编辑工具，界面如下图所示：

图3 动画编辑器界面

接下来我将一步一步的演示如何使用这个工具来制作动画：

1.         首先要建立一个工程，这个同时点击“”按钮引入一张图片，如下图：

图4 角色原始图片

从图中我们看到，原始图片不再是规则的帧序列，精灵图片被一块块的分解了。

2.         下面我们要对图片进行分割了，选中左边栏的“”，然后在图片上进行切割，把乌龟的各个零部件都用方块圈出来，最后的效果如下图：

图5 分割原始图片

3.         接下来就可以用这些“零件”拼图了。首先我们在右上方的窗口中点击“”按钮，接下来就可以看到右侧窗口变成如下图所示的界面：

图6 frame窗口

4.         接下来双击上图中的“1-Frame”，就会出现如下图所示界面：

图7 拼图界面

5.         接下来你就可以在左边的窗口中按住鼠标左键选择你要的乌龟的零部件图片并将其拖入右边窗口的坐标系中，一般将其放置到第一象限，一个拼好的帧图片如下图所示：

图8 帧的拼图

在拼图中，你可以使用左边的一些按钮来实现各个图块的位置和对齐，如图：

图9 布局排列按钮

可以点击“”来回到帧列表界面，同时可以使用“”按键增加新的帧。按照上述方法可以拼出乌龟的上、下、左、右行走等各个帧序列，拼好的效果如下图：

图10 拼好的各个帧

6.         有了帧图片就可以利用它们来组成动画了，方法如下：

菜单中选择“Action——Edit”，效果如下图：

图11 增加动画

图12 动画编辑界面

7.         接下来在“Action Edit”窗口中通过“”按钮增加一个动画，然后就可以从Frame列表中选择相应的帧来组成相应动画了，如下图所示：

图13 设置动画

这样我们就制作好了一个乌龟向下行走的动画，同时你可以点击“”按钮来观察这个动画，并根据效果对动画进行调整，非常方便。

现在我们已经完成了整个动画的制作过程，下面就要将数据进行导出，过程如下图所示：

图14 导出数据

上面介绍了如何使用动画编辑器来设定动画，相信你已经掌握了这个工具的使用了。但是，用这个工具制作的动画并不能直接显示到手机屏幕上，还需要我们通过代码的方式来对其进行处理。下面来介绍一下如何通过代码来绘制响应的动画。

动画播放类——Animation的实现：

要想实现对动画的播放必须要有一个动画的解析类，也就是需要对“.sprite”数据文件进行解析，这里我们将这个类命名为SpriteX，这个类的作用是解析数据文件并提供动画的绘制方法，因该类内容较多，此处没有贴出源代码，请参考附件。

精灵类——Role的实现

每个精灵类都需要有个SpriteX类的对象用来处理该精灵的动画，因此需要在这个类中定义如下属性：

SpriteX spx;     

精灵类的构造方法如下：

  • public Role(GameView view)  
    • 

  •  
    • 

  •     {  
    • 

  •  
    • 

  •        spx=new SpriteX("s.sprite",R.drawable.a2,view);  
    • 

  •  
    • 

  •     } 
    •

    这里面的“view”为视图类的对象，稍后会有介绍。

    注意：精灵图片需要放置到“res/drawable”文件夹，动画数据要放到“assets”文件夹下面。

    精灵类的绘制方法如下：

  • public void paint(Canvas g)  
    • 

  •  
    • 

  •     {  
    • 

  •  
    • 

  •         spx.paint(g,100,100);  
    • 

  •  
    • 

  •         spx.nextFrame();  
    • 

  •  
    • 

  •     } 
    •

    设计屏幕类

    定义好精灵类只是实现了这个项目的第一步，我们还不能在屏幕上看到精灵的动画，我们需要一个视图来把精灵显示出来，接下来我们定义视图类，在这里我们自定义一个类GameView来实现这个功能。作为一个自定义的视图类，这个类需要继承View，关于这个类请参考api文档。这个类用来处理精灵的绘制，按键处理等功能。其构造方法如下：

  • public GameView(Context view)  
    • 

  •  
    • 

  •     {  
    • 

  •  
    • 

  •        super(view);  
    • 

  •  
    • 

  •         
    • 

  •  
    • 

  •        gamePaint = new Paint();  
    • 

  •  
    • 

  •        player=new Role(this);  
    • 

  •  
    • 

  •    
    • 

  •  
    • 

  •        // 建立线程  
    • 

  •  
    • 

  •        Thread t = new Thread(this);  
    • 

  •  
    • 

  •        t.start();  
    • 

  •  
    • 

  • } 
    •

    精灵对象创建完毕后，我们就可以将其绘制到屏幕上了，这里需要重写View类中的onDraw()方法，此方法会在该类对象被Activity调用时自动调用，其方法如下：

  • @Override  
    • 

  •  
    • 

  •   protected void onDraw(Canvas g)  
    • 

  •  
    • 

  •   {  
    • 

  •  
    • 

  •      role.draw(gamePaint);  
    • 

  •  
    • 

  •   } 
    •

     

    动画的刷新

    在GameView类中需要处理动画的刷新，也就是每隔一段时间来播放动画的下一帧，因此我们用线程来实现这个功能，线程的run方法如下所示：

  • public void run()  
    • 

  •  
    • 

  •     {  
    • 

  •  
    • 

  •        while (true)  
    • 

  •  
    • 

  •        {  
    • 

  •  
    • 

  •            // 放慢速度  
    • 

  •  
    • 

  •            long bm = System.currentTimeMillis();  
    • 

  •  
    • 

  •            // 更新屏幕  
    • 

  •  
    • 

  •            postInvalidate();  
    • 

  •  
    • 

  •            long cm = System.currentTimeMillis();  
    • 

  •  
    • 

  •            if (cm - bm < SPLASH_RATE)  
    • 

  •  
    • 

  •               try  
    • 

  •  
    • 

  •               {  
    • 

  •  
    • 

  •                   Thread.sleep(SPLASH_RATE - (cm - bm));  
    • 

  •  
    • 

  •               } catch (InterruptedException e)  
    • 

  •  
    • 

  •               {  
    • 

  •  
    • 

  •                   e.printStackTrace();  
    • 

  •  
    • 

  •               }  
    • 

  •  
    • 

  •        }  
    • 

  •  
    • 

  •     } 
    •

    在这里要注意给线程适当的休眠时间，用来控制FPS，这样有利于得到更好的游戏体验。

    注意：SPLASH_RATE就是每个线程的间隔时间

    定义Activity

    最后我们定义一个Activity的子类用来运行该游戏，在Activitiy中我们需要创一个GameView对象，然后通过setContentView()方法进行设定，代码如下：

  • @Override  
    • 

  •  
    • 

  •     public void onCreate(Bundle savedInstanceState)  
    • 

  •  
    • 

  •     {  
    • 

  •  
    • 

  •         super.onCreate(savedInstanceState);  
    • 

  •  
    • 

  •         instance=this;  
    • 

  •  
    • 

  •          
    • 

  •  
    • 

  •         view=new GameView(this);  
    • 

  •  
    • 

  •         setContentView(view);  
    • 

  •  
    • 

  • } 
    •

    到此，我们已经完成了所有的功能，你可以运行模拟器并观察其效果了。

    总结

    使用动画编辑工具的方法可以非常方便的开发复杂的动画效果，尽可能的节约有限的内存资源并且使程序员和策划、美工的工作相分离，是现在手机端2D游戏开发普遍采用的一种高效、方便的方法。

    ]]>     http://www.javagg.com/archives/778/feed 0     J2ME平台PNG图片的压缩与解压缩 http://www.javagg.com/archives/718 http://www.javagg.com/archives/718#comments Fri, 02 Apr 2010 08:20:53 +0000 纯净水 http://www.javagg.com/archives/718 在J2ME平台上PNG图片格式几乎成为了标准，无数台手持设备上运行的J2ME程序几乎都选用PNG来显示图像，包括大量的手机游戏以及手机应用，所以对PNG文件格式的了解，可以更有效的减少Jar Size，保护自有知识产权。

    PNG文件格式：
    PNG文件格式分为PNG-24和PNG-8，其最大的区别是PNG-24是用24位来保存一个像素值，是真彩色，而PNG-8是用8位索引值来在 调色盘中索引一个颜色，因为一个索引值的最大上限为2的8次方既128，故调色盘中颜色数最多为128种，所以该文件格式又被叫做PNG-8 128仿色。
    PNG-24因为其图片容量过大，而且在Nokia和Moto等某些机型上创建图片失败和显示不正确等异常时有发生，有时还会严重拖慢显示速度，故并不常 用，CoCoMo认为这些异常和平台底层的图像解压不无关系。不过该格式最大的优点是可以保存Alpha通道，同事也曾有过利用该图片格式实现Alpha 混合的先例，想来随着技术的发展，手机硬件平台的提升，Alpha混合一定会被广泛的应用，到那时该格式的最大优势才会真正发挥。
    PNG-8文件是目前广泛应用的PNG图像格式，其主要有六大块组成：
    1.文件头
    2.IHDR块
    3.PLTE块
    4.tRNS块
    5.IDAT块
    6.文件尾
    这六大块按顺序排列，也就是说IDAT块永远是在PLTE块之后，期间也会有许多其他的区块用来描述信息，例如图像的最后修改时间是多少，图像的创建者是谁等，不过这些区块的信息对我们来说都是可有可无的描述信息，故压缩时一般先向这些区块开刀。

    数据块：
    除了文件头，其中四大数据块和文件尾都是由统一的数据块文件结构描述的：
    Chunk Length: 4byte
    Chunk Type:   4byte
    Chunk Data:   Chunk Length的长度
    Chunk CRC:    4byte
    例如IHDR块的数据长度为13，既
    Chunk Length = 13
    Chunk Type = “IHDR”

    文件头：
    用来标示PNG文件，为固定的64个字节：0×89504e47 0×0d0a1a0a

    IHDR块：
    用来描述图像的基本信息，其格式为：
    图像宽：    4byte
    图像高：    4byte
    图像色深： 4byte
    颜色类型： 1byte
    压缩方法： 1byte
    滤波方法： 1byte
    扫描方法： 1byte
    曾经有人问过我，撒叫滤波方法和扫描方法，汗，说实话我也不知道，不过我们是在做手机游戏，不是在搞图形学不是嘛。

    PLTE块：
    这个就是传说中放置调色盘数据的地方啦，其格式为：
    循环
    RED：    1byte
    GREEN：1byte
    BLUE：  1byte
    END
    循环长度嘛，不就是Chunk Length / 3的长度嘛，而且Chunk Length一定为3的倍数。

    tRNS块：
    这个块时有时无，主要是看你是否使用了透明色。该区块的格式为：
    循环
    if(对应调色盘颜色非透明)
    0xFF：  1byte
    else
    0×00：  1byte
    END
    循环长度为调色盘的颜色数，相当于调色盘颜色表的一个对应表，标识该颜色是否透明，0xFF不透明，0×00透明。故如果用UltraEdit查看PNG文件的二进制编码，如果看到一大片FF，一般就是tRNS区块啦，因为一个PNG文件一般只有一个透明色。

    IDAT块：
    这个就是存放图像数据的地方啦，这里要注意的是一个PNG文件可能有多个IDAT区块，而其他三大区块只可能有一个。
    IDAT区块是经过压缩的，所以数据不可读，压缩算法一般为LZ77滑动窗口算法，如果硬要看里面的数据的话，用zlib库也是可以的，CoCoMo当年 就见过Windows Mobile上的帝国时代巨变态的用zlib库压缩和解压该区块来进一步减少PNG文件大小，真是寸K寸金啊。

    IEND块：
    该区块虽然也按照数据块的结构，但Chunk Data是没有的，所以是固定的96个字节：0×00000000 0×49454e44 0xae426082

    PNG图像压缩：
    了解了PNG的文件结构，压缩就有的放矢了。压缩有6个级别，可以根据需要选择。
    Level1：读取PNG文件，将除六大块之外的所有区块都过滤掉
    Level2：文件头是固定的0×89504e47 0×0d0a1a0a，文件尾是固定的0×00000000 0×49454e44 0xae426082，去掉！
    Level3：每个区块的Chunk Type我们是否需要呢？很明显，我们自己写的压缩格式自己应该清楚是按照什么样的顺序，去掉！
    Level4：每个区块的Chunk Length我们是否需要呢？
    IHDR块：定长13个字节，明显不需要，去掉。
    PLTE块：最多128个颜色，为撒要用4byte来记录区块长度而不是用1byte来记录颜色数呢？
    tRNS块：既然有颜色数，tRNS又是调色盘颜色表的对应表，既数量与颜色数相同，为撒还需要呢？
    IDAT块：我想这个是唯一需要4byte来记录长度的区块。
    Level5：每个区块的Chunk CRC是否需要呢？
    因为计算CRC需要一些时间，但对于字节较少的区块一般可以忽略不计，所以对于这个问题还是由程序员自己决定吧。对于CRC的计算可以参看CoCoMo的另一篇Blog“PNG文件的CRC码计算”
    Level6：每个区块我们是否要原封不动的保存期数据呢？
    IHDR块：除了宽、高、色深是需要的，后面那4byte的信息是固定的0×03000000
    PLTE块：为撒要用3byte来表示RGB而不是2byte的565格式？压缩方法可以参看CoCoMo的另一篇Blog“关于PNG图像压缩的一点感悟”
    tRNS块：我想tRNS块是冗余最多的区块了吧，大段大段的0xFF明显没有必要，一般的PNG文件只有一个透明色，为撒要用对应表的方法而不是一个索 引来记录到底哪个是透明色呢？由于颜色数最多128，所以只需1byte就可以代替tRNS那么多0xFF啦。
    IDAT块：么想法，如果你够变态，把zlib加进来吧！

    PNG图像解压：
    创建了自定义的文件，J2ME端读取后，就面临解压的问题了。我们可以利用此函数来创建Image：
    static Image
    createImage(byte[] imageData, int imageOffset, int imageLength)
    前提是传入的imageData与PNG未被压缩前的一致。因为PNG文件格式是固定的，所以读取自定义的压缩文件后，开始将那些默认的数据再添加进去，实现解压的目的。下面就开始解压之旅吧!
    首先要创建一个ByteArrayOutputStream out，
    1.写入文件头：
    out.writeInt(0×89504e47);
    out.writeInt(0×0d0a1a0a);
    2.写入IHDR块
    out.writeInt(13);
    out.writeInt(0×49484452);  //0×49484452为Chunk Type “IHDR”
    out.writeInt(width);
    out.writeInt(height);
    out.writeByte(depth);
    out.writeInt(0×03000000);  //压缩时舍掉的4byte，默认0×03000000
    out.writeInt(crc);
    其他区块方法一致，故略过。。。
    3.写入文件尾
    out.writeInt(0×00000000);
    out.writeInt(0×49454e44);
    out.writeInt(0xae426082);
    4.转换成数组，创建Image
    byte[] pngBuffer = out.toByteArray();
    Image image = Image.createImage(pngBuffer, 0, pngBuffer.length);
    哈哈，大功告成。这里注意如果中途数据写入有错误，经常会出现创建Image失败的异常，而且非常不好调试，不过只要自定的压缩格式定下来后，对应的创建Image的函数只要写一次，以后基本不会出问题哈。

    PNG图像加解密：
    很多人都担心自己辛苦创作的漂亮的美术图片很easy就被别人拿到了，究其原因是由于PNG文件格式是固定的，稍微了解的人用UltraEdit很 容易就能找到IHDR，PLTE等标识了。CoCoMo就经常看GameLoft的图像文件，哈哈。一般是2byte的Length，然后紧接着图片数 据，都放在一个文件里，直接拷贝2进制然后粘贴到一个新文件里就是一幅图。后来的加密技术会把PNG分块，例如前100个字节一块，紧接着1K一块，最后 剩余字节一块，然后把块顺序打乱，用2byte来记录总长度，1byte记录顺序，但是这并没有从根本上消除IHDR，IEND这些显眼的定位标识，好像 在对破解者说：嘿，看，我就在这里！
    现在了解了之前的压缩和解压技术，这个问题也就迎刃而解了，因为Chunk Length，Chunk Type和Chunk CRC这些东西都消失了，甚至连数据块本身的数据都修改了，我可以按照ImageWidth、ImageHeight、ImageDepth的顺序写数 据，也可以倒过来写。我想再牛的PNG分析器也是无能为力的吧，唯一可以定位的就只有IDAT区块了，不过就算得到该区块的数据，也应该是一张黑白图。

    ]]>     http://www.javagg.com/archives/718/feed 0     应用双缓冲技术解决画面闪烁的问题 http://www.javagg.com/archives/566 http://www.javagg.com/archives/566#comments Fri, 05 Mar 2010 15:36:01 +0000 纯净水 eric_DIARY_105790599 有些时候我们可能在J2ME中遇到画面闪烁的问题，这时候我们可以应用双缓冲的技术来解决，不过由于现在越来越多的手机自身就支持双缓冲了。所以这里只做个简单的介绍。

    我写了程序本来想在NOkia 6108上比较用和不用的区别，结果这个手机自己就支持双缓冲，所以根本没有比较出来。不过了解这个技术还是有必要的，所以我决定还是写出来。双缓冲本来是在开发PC应用程序的时候遇到的。在MIDP开发中同样存在，当你在屏幕上进行原始写画的时候，如果很复杂的话，用户会发现界面在闪烁。因此你可以这样做，首先在另一个图片上进行paint()得操作，当完成了以后就把它copy到屏幕上，由于通常copy得时候速度很快就不会出现闪烁了。这个技术就是双缓冲。

    Canvas类提供了isDoubleBuffered()方法来判断设备是不是支持这个功能，如果返回true的话，那么我们就没有必要使用双缓冲了，如果false的话，我们可以这么做：
    public DoubleCanvas(UIController uicontroller)
    {
    super();
    this.uicontroller = uicontroller;
    width = this.getWidth();
    height = this.getHeight();
    this.setCommandListener(this);
    if(!isDoubleBuffered())
    {
    offImage = Image.createImage(width,height);
    }

    }
    protected void paint(Graphics arg0)
    {

    arg0.drawString(isDoubleBuffered()+”",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
    Graphics saved = arg0;
    if(offImage != null)
    {
    arg0 = offImage.getGraphics();
    }
    arg0.setColor(255,128,128);
    for(int i = 2,j=2;i<width/2-6&&j<height/2-6;i=i+2,j=j+2)
    {
    arg0.drawRect(i,j,width-2*i,height-2*j);
    }
    if(arg0 != saved)
    {
    saved.drawImage(offImage,0,0,Graphics.LEFT|Graphics.TOP);
    }

    }

    得到offImage得Graphics实例后，进行paint()得操作。这个部分通常比较复杂，我这里的不够复杂：）
    然后把offImage直接copy到屏幕上也就是执行    saved.drawImage(offImage,0,0,Graphics.LEFT|Graphics.TOP);

    我写了一个应用程序来比较使用和不使用双缓冲的效果，但是由于我的手机支持双缓冲所以看不出效果，如果你有兴趣，那么可以把paint()部分的代码修改的复杂一些然后再移植到不支持的手机上也许可以看出效果，下面是我程序的代码：

    import javax.microedition.midlet.MIDlet;
    import javax.microedition.midlet.MIDletStateChangeException;


    public class DoubleBufferMIDlet extends MIDlet
    {
    private UIController uicontroller;

    protected void startApp() throws MIDletStateChangeException
    {
    uicontroller = new UIController(this);
    uicontroller.init();

    }

    protected void pauseApp()
    {

    }


    protected void destroyApp(boolean arg0) throws MIDletStateChangeException
    {
     }

    }

    import javax.microedition.lcdui.Command;
    import javax.microedition.lcdui.CommandListener;
    import javax.microedition.lcdui.Displayable;
    import javax.microedition.lcdui.List;


    public class MainListUI extends List implements CommandListener
    {
    private UIController uicontroller;

    public MainListUI(UIController uicontroller)
    {
    super(“Test”,List.IMPLICIT);
    this.uicontroller = uicontroller;
    this.append(“Non-buffer”,null);
    this.append(“Double-buffer”,null);
    this.setCommandListener(this);
    }

    public void commandAction(Command arg0, Displayable arg1)
    {

    if(arg0 == List.SELECT_COMMAND)
    {
    if(this.getSelectedIndex() == 0)
    {

    uicontroller.handleEvent(UIController.EventID.DISPLAY_NON_BUFFER);
    }
    else
    {

    uicontroller.handleEvent(UIController.EventID.DISPLAY_BUFFER);
    }
    }

    }

    }

    import javax.microedition.lcdui.Command;
    import javax.microedition.lcdui.CommandListener;
    import javax.microedition.lcdui.Display;
    import javax.microedition.lcdui.Displayable;


    public class UIController implements CommandListener
    {

    private Display display;
    private DoubleBufferMIDlet midlet;
    private MainListUI mainList;
    private NonDoubleCanvas noDoubleCanvas;
    private DoubleCanvas doubleCanvas;
    public static final Command backCommand = new Command(“Back”,Command.BACK,2);

    public static class EventID
    {
    public static final int DISPLAY_NON_BUFFER = 0;
    public static final int DISPLAY_BUFFER = 1;
    }

    public UIController(DoubleBufferMIDlet midlet)
    {
    this.midlet = midlet;
    }

    public void init()
    {
    display = Display.getDisplay(midlet);
    mainList = new MainListUI(this);
    noDoubleCanvas = new NonDoubleCanvas(this);
    doubleCanvas = new DoubleCanvas(this);
    addCommand();
    display.setCurrent(mainList);
    }

    public void addCommand()
    {
    noDoubleCanvas.addCommand(backCommand);
    doubleCanvas.addCommand(backCommand);
    }

    public Display getDisplay()
    {
    return display;
    }

    public void setCurrent(Displayable disp)
    {
    display.setCurrent(disp);
    }

    public void handleEvent(int eventID)
    {
    switch(eventID)
    {
    case EventID.DISPLAY_BUFFER:
    {
    setCurrent(doubleCanvas);
    System.out.println(EventID.DISPLAY_BUFFER);
    break;
    }
    case EventID.DISPLAY_NON_BUFFER:
    {
    setCurrent(noDoubleCanvas);
    System.out.println(EventID.DISPLAY_NON_BUFFER);
    break;
    }
    }
    }
    public void commandAction(Command arg0, Displayable arg1)
    {

    if(arg0 == backCommand)
    {
    display.setCurrent(mainList);
    }

    }

    }

    import javax.microedition.lcdui.Canvas;
    import javax.microedition.lcdui.Command;
    import javax.microedition.lcdui.CommandListener;
    import javax.microedition.lcdui.Displayable;
    import javax.microedition.lcdui.Graphics;

    public class NonDoubleCanvas extends Canvas implements CommandListener
    {

    private UIController uicontroller;
    private int width;
    private int height;

    public NonDoubleCanvas(UIController uicontroller)
    {
    super();
    this.uicontroller = uicontroller;
    width = this.getWidth();
    height = this.getHeight();
    this.setCommandListener(this);
    }


    protected void paint(Graphics arg0)
    {

    arg0.setColor(100,100,100);
    arg0.drawString(isDoubleBuffered()+”",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
    for(int i = 2,j=2;i<width/2-6&&j<height/2-6;i=i+2,j=j+2)
    {
    arg0.drawRect(i,j,width-2*i,height-2*j);
    }

    }

    public void commandAction(Command arg0, Displayable arg1)
    {

    uicontroller.commandAction(arg0,arg1);
    }

    }

    import javax.microedition.lcdui.Canvas;
    import javax.microedition.lcdui.Command;
    import javax.microedition.lcdui.CommandListener;
    import javax.microedition.lcdui.Displayable;
    import javax.microedition.lcdui.Graphics;
    import javax.microedition.lcdui.Image;

    public class DoubleCanvas extends Canvas implements CommandListener
    {


    private UIController uicontroller;
    private Image offImage;
    private int width;
    private int height;

    public DoubleCanvas(UIController uicontroller)
    {
    super();
    this.uicontroller = uicontroller;
    width = this.getWidth();
    height = this.getHeight();
    this.setCommandListener(this);
    if(!isDoubleBuffered())
    {
    offImage = Image.createImage(width,height);
    }

    }


    protected void paint(Graphics arg0)
    {

    arg0.drawString(isDoubleBuffered()+”",width/2,height/2,Graphics.HCENTER|Graphics.TOP);
    Graphics saved = arg0;
    if(offImage != null)
    {
    arg0 = offImage.getGraphics();
    }
    arg0.setColor(255,128,128);
    for(int i = 2,j=2;i<width/2-6&&j<height/2-6;i=i+2,j=j+2)
    {
    arg0.drawRect(i,j,width-2*i,height-2*j);
    }
    if(arg0 != saved)
    {
    saved.drawImage(offImage,0,0,Graphics.LEFT|Graphics.TOP);
    }

    }

    public void commandAction(Command arg0, Displayable arg1)
    {
    uicontroller.commandAction(arg0,arg1);
    }

    }

    ]]>     http://www.javagg.com/archives/566/feed 0