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

他有两种方式一种是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二种方法

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;
}
}