J2ME手机游戏设计案例源代码-GameEngine-TiledLayer

********GameMID。Java

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

import javax.microedition.lcdui.Display;

import javax.microedition.midlet.*;

/**

 * @author Administrator

 */

public class GameMID extends MIDlet {

    private Display display;

    private GameWorld gw=null;

    public GameMID(){

        display = Display.getDisplay(this); //获取Display

        gw=new GameWorld(this);         //创建游戏画布

        display.setCurrent(gw);         //设置游戏画布为当前显示画面

    }

   

    public void startApp() {

        if(gw!=null){

                gw.start(); //游戏开始执行

            }

    }

    public void pauseApp() {

        if(gw!=null){

                     gw.setPaused(true); //游戏暂停执行

              }

    }

    public void destroyApp(boolean unconditional) {

       

    }

    /* 退出程序 */

    public void exit(){

       try{

           destroyApp(false);

           }catch(Exception e){}

       notifyDestroyed();

    }

}

**********GameWorld。Java

import java.io.IOException;

import javax.microedition.lcdui.Font;

import javax.microedition.lcdui.Graphics;

import javax.microedition.lcdui.Image;

import javax.microedition.lcdui.game.GameCanvas;

import javax.microedition.lcdui.game.Sprite;

import javax.microedition.lcdui.game.TiledLayer;

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

/**

 *

 * @author Administrator

 */

public class GameWorld extends GameCanvas implements Runnable{

    GameMID mid;                //游戏MIDlet

    Thread MainThread;          //游戏主线程

    private final int MS_PER_FRAME=30;   //设置一次游戏循环所需时间，单位为毫秒（ms），每秒游戏帧数约为1000/MS_PER_FRAME   

    private int cps;            //游戏帧速

    private boolean isPaused;   //游戏暂停状态

    private boolean running;    //游戏运行状态

   

    Graphics g;                 //游戏绘图对象

    public static int ScreenWidth;    //游戏屏幕宽度，设置为静态成员，方便外部访问

    public static int ScreenHeight;   //游戏屏幕高度

    public static int GameState;        //游戏状态,1为暂停，2为游戏进行中，3为游戏失败

    public static int  KeyState;        //按键状态

    private Image imgEnemy,imgBoy; //精灵图像

    private Sprite sprEnemy;    //定义敌人精灵

    private MySprite sprBoy;    //用扩展的精灵类来定义玩家精灵

    //定义三个不同方向的玩家精灵帧序列，右方向可由左方向镜像变换得到

    int LSequ[]={3,4,3,5};      //定义左方向精灵帧序列

    int USequ[]={6,7,6,8};      //定义上方向精灵帧序列

    int DSequ[]={0,1,0,2};      //定义下方向精灵帧序列

    int enemyX,enemyY;  //敌人精灵坐标

    int enemySpeedX;    //敌人精灵速度,这里设置为只能水平移动

    boolean isColl;     //碰撞标志

    long CollTextTime;   //碰撞文本显示时间

    TiledBg tbg;        //创建贴图层应用类

    TiledLayer tl;      //创建贴图层类

       //定义字体

       private Font largeFont=Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD, Font.SIZE_LARGE);

    private Font mediumFont=Font.getFont(Font.FACE_SYSTEM,Font.STYLE_BOLD, Font.SIZE_MEDIUM);

    public GameWorld(GameMID midlet)

    {

        super(true);

        this.mid=midlet;            //获取MIDlet

       

            this.setFullScreenMode(true);   //设置为全屏模式

            ScreenWidth=getWidth();         //获取屏幕大小

            ScreenHeight=getHeight();

            g=this.getGraphics();           //获取绘图对象

        

            running=false;                  //设置游戏运行状态

            isPaused=false;

            GameInit();                     //游戏初始化

    }

    /* 游戏初始化 */

    private void GameInit()  {

        try {

            imgBoy = Image.createImage("/Boy.png");

            imgEnemy=Image.createImage("/enemy.png");

        } catch (IOException ex) {

            ex.printStackTrace();

        }

        // 使用Image对象，帧宽度、帧高度，速度，限制范围矩形左上角的X坐标、Y坐标、高度和宽度来构造自定义精灵

        sprBoy=new MySprite(imgBoy,32,48,3,0,0,ScreenWidth,ScreenHeight);

        sprBoy.setFrameSequence(LSequ);    //设置初始化时的精灵帧序列和方向

        sprBoy.setDir( MySprite.LEFT);    //设置初始化时精灵方向

        sprBoy.defineReferencePixel(sprBoy.getWidth()/2, sprBoy.getHeight()/2); //设置参考点

        sprBoy.setRefPixelPosition(ScreenWidth/2, ScreenHeight/2);       //通过参考点定位精灵

        int sw=sprBoy.getWidth();

        int sh=sprBoy.getHeight();

        sprBoy.defineCollisionRectangle(sw/10, sh/10, sw*8/10,sh*8/10); //重设精灵的碰撞矩形范围为原来的80％

        //创建敌人精灵

        sprEnemy=new Sprite(imgEnemy,imgEnemy.getWidth()/3,imgEnemy.getHeight()/3);

        sprEnemy.setFrameSequence(LSequ);       //设置精灵循环序列

        enemyX=50;      //设置敌人精灵的坐标

        enemyY=200;

        enemySpeedX=-2; //设置敌人精灵速度

        tbg=new TiledBg();      //创建TiledBg对象

        tl=tbg.getTiledbg();    //获取贴图层

    }

    /* 游戏运行 */

    public void run(){

        int cyclesThisSecond=0;     //当前1秒内的循环次数

        long cycleStartTime;        //循环开始时间

        long lastCPSTime=0;         //上次计算帧速的时间

        long cycleEndTime=0;        //循环结束时间

        long cycleTimes=0;          //一次游戏循环热所花的时间

       

        boolean bSkip = false;      //游戏是否跳帧

        cps=0;

        System.out.println("游戏开始");//在控制台输出开始信息，可屏蔽

       

        /* 游戏主循环 */

        while(running){        //检查是否运行

       

            cycleStartTime = System.currentTimeMillis();//记录游戏循环开始时间

           

            // 下面语句用于处理游戏内容，如果游戏设置为跳帧,

            // 则本次循环不处理游戏内容             

            if(!bSkip)

                     {

                GameInput();        //处理输入消息

                GameCycle();        //处理游戏逻辑

                render(g);          //渲染游戏画面

                flushGraphics();    //更新画面                      

            }

         

            /* 下面语句用于计算游戏循环时间，并进行相应处理 */

           cycleEndTime=System.currentTimeMillis();     //记录游戏循环结束时间

           cycleTimes=cycleEndTime-cycleStartTime;      //计算循环时间

           //如果循环时间间隔小于MS_PER_FRAME，则通过休眠，使其不小于rate,

           //并能让系统有空闲转去处理其他事务

           if(cycleTimes<MS_PER_FRAME){

              bSkip = false;

              try {

                Thread.sleep(MS_PER_FRAME - cycleTimes);  //休眠

              }

              catch (InterruptedException ex) {

                  ex.printStackTrace();

              }

            }

            else{                  

                //如果循环时间大于MS_PER_FRAME，则设置bSkip为true，

                //让程序跳过一次循环，以主动丢帧的方式换取游戏速度

                      bSkip = true;

            }

       

             //下面语句用于计算每秒的循环次数，即帧速，在游戏中如果不需要，

                     //可将这部分语句及相关变量注释屏蔽

             if (System.currentTimeMillis() - lastCPSTime > 1000){  //检查距上次计算帧数的

                                                                                                         //时间是否经过1000ms

                lastCPSTime=System.currentTimeMillis(); //设定lastCPS为当前时间

                cps = cyclesThisSecond;

         //       System.out.println("cps："+cps);    //输出每秒的帧数

                cyclesThisSecond = 0;             //重置帧数

             }

                     else {

                cyclesThisSecond++;               //帧数递增

            }

       }

        System.out.println("游戏结束！");

        release();      //释放资源

        exit();         //退出游戏

    }

    /* 启动游戏进程 */

    public void start(){

        //检查游戏循环是否处于运行状态，如果未运行，则创建线程并启动

        //如果游戏处于运行状态，则表示是暂停后的继续执行，仅设置暂停状态即可

         if(!running){

            running=true;

            MainThread=new Thread(this);

            MainThread.start();

            GameState=2;

        }

        else{

            GameState=2;

            setPaused(false);

        }

    }

    //退出游戏

    private void exit() {

        mid.exit();     //退出游戏

    }

    /* 停止游戏 */

    private void stop(){

        running=false;  //终止游戏循环

    }

    /* 释放游戏资源 */

    private void release(){

        //此处为释放游戏资源的代码

        imgEnemy=null;

        imgBoy=null;

        sprBoy=null;

        sprEnemy=null;

        tbg=null;

        tl=null;

        System.gc();

    }

     /*　获取暂停状态  */

    public boolean getPaused() {

        return isPaused;

    }

    /* 设置暂停状态  */

    public void setPaused(boolean isPaused) {

        this.isPaused = isPaused;

    }

    /* 处理游戏输入信息 */

    private void GameInput() {

       int keyStates = this.getKeyStates();     //获取按键状态

       /* 下面是对按键事件的具体处理，应根据游戏需要进行修改*/

       KeyState=0;

       //Fire

       if((keyStates &  FIRE_PRESSED )!=0){

           KeyState=FIRE_PRESSED;

        }

       

        // Left

        if ((keyStates & LEFT_PRESSED) != 0){

            KeyState=LEFT_PRESSED;

        }

        // Right

        if ((keyStates & RIGHT_PRESSED) !=0 ){

            KeyState=RIGHT_PRESSED;

        }

        // Up

        if ((keyStates & UP_PRESSED) != 0) {

            KeyState=UP_PRESSED;

        }

        // Down

        if ((keyStates & DOWN_PRESSED) !=0) {

            KeyState=DOWN_PRESSED;

        }

        //Game_A

        if((keyStates & GAME_A_PRESSED)!=0) {

            KeyState=GAME_A_PRESSED;

        }

        //Game_B

       if((keyStates & GAME_B_PRESSED)!=0){

            KeyState=GAME_B_PRESSED;

       }

       //Game_C

        if((keyStates & GAME_C_PRESSED)!=0) {

            KeyState=GAME_C_PRESSED;

        }

        //Game_D

       if((keyStates & GAME_D_PRESSED)!=0){

            KeyState=GAME_D_PRESSED;

       }

    }

    /* 渲染游戏画面 */

    private void render(Graphics g)  {

        /* 填充背景 */

        g.setColor(0xffffff);

        g.fillRect(0, 0, ScreenWidth,ScreenHeight);

       /* 下面是对游戏渲染的具体处理，应根据游戏需要进行修改*/

        tl.paint(g);    //绘制贴图层

  //      g.drawImage(imgBuild,100, 50, Graphics.LEFT|Graphics.TOP);

        sprEnemy.paint(g);  //绘制敌人精灵

        sprBoy.paint(g);    //绘制精灵

        //当敌人精灵和玩家角色相碰撞时，绘制下面的内容

        if(isColl){

            g.setColor(0xccbbcc);

            g.fillRect(50, 0, 120, 20);

            g.setColor(0xffffff);

            g.setFont(largeFont);

            g.drawString("被敌人撞上啦！",60,0, Graphics.LEFT| Graphics.TOP);

        }

    

    }

   

    /* 游戏逻辑处理*/

    private void GameCycle() {

        switch(GameState){

            case 1:         //游戏暂停状态时的处理

                //根据按键状态执行相应功能

                switch(KeyState){

       

                    case GAME_A_PRESSED:      //按下GAME_A键时的处理

                            GameState=4;      //设置游戏状态会结束程序

                        break;

                    case FIRE_PRESSED:        //按下FIRE键时的处理

                            if(getPaused()){

                                GameState=2;

                                setPaused(false);

                            }

                    break;

                }

                break;

            case 2:     //游戏处于运行状态时的处理

                {

                    //根据按键状态执行相应功能

                       //根据按键状态进行计算

                    switch(KeyState){

                        case FIRE_PRESSED:      //按下Fire键时

                            GameState=1;        //设置游戏状态为暂停

                            setPaused(true);    //设置暂停

                            break;

                        case GAME_A_PRESSED:    //按下Game_A键时

                            GameState=4;        //设置游戏状态为退出

                            break;

                        case GAME_B_PRESSED:     //按下Game_B键时

                            sprBoy.setFrame(2);

                            break;

                        default:

                            update();           //更新数据

                            break;

                    }

                }

                break;

              

            case 3:     //游戏失败的处理

                break;

               

            case 4:     //游戏退出时的处理

                    stop();         //停止运行

                break;

        }

     }

 /* 更新数据 */

    private void update(){

        //敌人的运动

        enemyX+=enemySpeedX;    //计算坐标

        if(enemyX>=ScreenWidth+sprEnemy.getWidth() && enemySpeedX>0) {

            enemySpeedX=-enemySpeedX;   //改变速度方向

            sprEnemy.setTransform(Sprite.TRANS_NONE);

        }

        if(enemyX+sprEnemy.getWidth()<=0 && enemySpeedX<0 )  {

            enemySpeedX=-enemySpeedX;   //改变速度方向

            sprEnemy.setTransform(Sprite.TRANS_MIRROR);

        }

        sprEnemy.setRefPixelPosition(enemyX, enemyY); //设置敌人位置

        sprEnemy.nextFrame();   //精灵动画移到后一帧

         //检测玩家角色是否与敌人相碰撞，如果是，则后退

        if( sprBoy.collidesWith(sprEnemy,false)){

            //通过敌人的速度方向来检查是从哪个方向撞上的，并作相应动作

            if(sprEnemy.getX()>sprBoy.getX()) {

                sprBoy.move(-sprBoy.getSpeed(), 0);          //移动玩家角色精灵

                sprEnemy.setTransform(Sprite.TRANS_MIRROR);   //设置敌人精灵方向

                enemyX+=sprEnemy.getWidth();                  //重设敌人精灵坐标

                enemySpeedX=2;                                //设置敌人精灵速度方向

            }

            else{

                sprBoy.move(sprBoy.getSpeed(), 0);              //移动玩家角色精灵

                sprEnemy.setTransform(Sprite.TRANS_NONE);       //设置敌人精灵方向

                enemyX-=sprEnemy.getWidth();                    //重设敌人精灵坐标

                enemySpeedX=-2;                                //设置敌人精灵速度方向

            }

            sprEnemy.setRefPixelPosition(enemyX, enemyY);       //重设敌人位置

            isColl=true;        //设置碰撞标志

            CollTextTime=120;    //设置碰撞文本显示时间

        }

        else if(CollTextTime<=0){

            isColl=false;

        }

        CollTextTime--;         //设置碰撞文本显示时间递减

         //根据按键状态计算玩家角色精灵与贴图层数据

         switch(KeyState){

            case LEFT_PRESSED:      //按下Left键时

                //检查原来是否为左方向的精灵帧序列，如果不是则设置为左方向精灵帧序列

                if(sprBoy.getDir()!=MySprite.LEFT){

                    sprBoy.setFrameSequence(LSequ);     //设置左方向精灵序列

                    sprBoy.setTransform(MySprite.TRANS_NONE); //设置为不变换

                }

                if(sprBoy.move(MySprite.LEFT)){     //向左移动，如果到屏幕边缘则移动贴图层

                    tbg.move(sprBoy.getSpeed(), 0);

                }

                break;

            case RIGHT_PRESSED:     //按下Right键时

                //检查原来是否为右方向的精灵帧序列，如果不是则设置为右方向精灵帧序列

                if(sprBoy.getDir()!=MySprite.RIGHT){

                    sprBoy.setFrameSequence(LSequ);     //设置左方向精灵帧序列

                    sprBoy.setTransform(MySprite.TRANS_MIRROR); //设置为镜像变换

                }

                //向右移动，如果到屏幕边缘则移动贴图层

                if(sprBoy.move(MySprite.RIGHT)){

                    tbg.move(-sprBoy.getSpeed(), 0);

                }

                break;

            case UP_PRESSED:        //按下Up键时

                //检查原来是否为上方向的精灵帧序列，如果不是则设置为上方向精灵帧序列

                if(sprBoy.getDir()!=MySprite.UP){

                    sprBoy.setFrameSequence(USequ);

                }

                //向上移动，如果到屏幕边缘则移动贴图层

                if(sprBoy.move(MySprite. UP)){

                    tbg.move(0,sprBoy.getSpeed() );

                }

                break;

            case DOWN_PRESSED:        //按下Right键时

               //检查原来是否为下方向的精灵帧序列，如果不是则设置为下方向精灵帧序列

                if(sprBoy.getDir()!=MySprite.DOWN){

                    sprBoy.setFrameSequence(DSequ);

                }

                //向下移动，如果到屏幕边缘则移动贴图层

                if( sprBoy.move(MySprite.DOWN)){

                    tbg.move(0,-sprBoy.getSpeed() );

                }

                break;

            }

        tbg.update();        //更新动态贴图

   

    }

}

************MySprite.java

import javax.microedition.lcdui.Image;

import javax.microedition.lcdui.game.Sprite;

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

/**

 *

 * @author Administrator

 */

public class MySprite extends Sprite{

    private int speed;      //速度

    private int dir;        //方向

   

    private int RoundX;     //限制矩形范围的左上角坐标   

    private int RoundY;      

    private int RoundWidth;     //限制矩形范围宽度   

    private int RoundHeight;     //限制矩形范围高度

    //定义各方向静态常量

    public final static int LEFT=1;        //左

    public final static int RIGHT=2;        //右

    public final static int UP=3;        //上

    public final static int DOWN=4;        //下

    /* 使用Image对象，帧宽度w和帧高度h构造精灵*/

    public MySprite(Image img,int w,int h){

        super(img,w,h); //使用基类（即Sprite）构造方法创建精灵

        this.speed=1;   //设置默认速度

        setDir(DOWN);          //设置默认方向

        setRoundRect(0,0,240,309);  //设置缺省时的限制矩形       

    }

   

    /* 使用Image对象，帧宽度w、帧高度h和速度speed构造精灵 */

    public MySprite(Image img,int w,int h,int speed){

        super(img,w,h);

        this.speed=speed;

        setDir(DOWN);              //设置默认方向

    }   

   

    

    /* 使用Image对象，帧宽度、帧高度，速度，限制范围矩形左上角的X坐标、Y坐标、高度和宽度来构造精灵  */

    public MySprite(Image img,int w,int h,int speed,int rx,int ry,int rw,int rh){

        super(img,w,h);

        this.speed=speed;               //设置速度

        setDir(DOWN);                          //设置默认方向

        setRoundRect(rx,ry,rw,rh);      //设置限制范围矩形       

    }   

       

    /* 设置限制范围矩形 */

    public void setRoundRect(int rx,int ry,int rw,int rh){

        setRoundX(rx);

        setRoundY(ry);

        setRoundWidth(rw);

        setRoundHeight(rh);

    }

    /* 向dir方向移动精灵,并返回是否已到达范围矩形边框*/

    public boolean move(int dir){

        boolean isRound;

        isRound=false;

        int moveX=0;       

        int moveY=0;

       

        this.setDir(dir);   //设置方向

        switch(dir){        //通过方向，按设置的速度距离移动精灵

            case LEFT:

                moveX=-getSpeed();

                break;

            case RIGHT:

                moveX=getSpeed();

                break;  

            case UP:

                moveY=-getSpeed();

                break;  

            case DOWN:

                moveY=getSpeed();

                break;  

        }

        //下面语句用于将移动点在范围矩形内

        if( getX()+moveX<getRoundX()){

            moveX=getRoundX()-getX();

            isRound=true;

        }

        else if( getX()+moveX+getWidth()>getRoundX()+getRoundWidth()){

            moveX=getRoundX()+getRoundWidth()-getX()-getWidth();

            isRound=true;           

        }

       

        if( getY()+moveY<getRoundY()){

            moveY=getRoundY()-getY();

            isRound=true;                   

        }

        else if( getY()+moveY+getHeight()>getRoundY()+getRoundHeight()){

            moveY=getRoundY()+getRoundHeight()-getY()-getHeight();

            isRound=true;                

        }       

        super.nextFrame(); 

        super.move(moveX, moveY);   //调用基类方法移动精灵

        return isRound;

    }

    /* 获取速度 */

    public int getSpeed() {

        return speed;

    }

    /* 设置速度 */

    public void setSpeed(int speed) {

        this.speed = speed;

    }

    /* 获取方向 */

    public int getDir() {

        return dir;

    }

    /* 设置方向 */

    public void setDir(int dir) {

        this.dir = dir;

    }

    /* 获取限制框X坐标    */

    public int getRoundX() {

        return RoundX;

    }

    /*  设置限制框X坐标   */

    public void setRoundX(int RoundX) {

        this.RoundX = RoundX;

    }

    /* 获取限制框Y坐标    */

    public int getRoundY() {

        return RoundY;

    }

    /* 设置限制框Y坐标     */

    public void setRoundY(int RoundY) {

        this.RoundY = RoundY;

    }

    /* 获取限制框宽度    */

    public int getRoundWidth() {

        return RoundWidth;

    }

    /* 设置限制框宽度     */

    public void setRoundWidth(int RoundWidth) {

        this.RoundWidth = RoundWidth;

    }

    /* 获取限制框高度    */

    public int getRoundHeight() {

        return RoundHeight;

    }

    /* 设置限制框高度    */

    public void setRoundHeight(int RoundHeight) {

        this.RoundHeight = RoundHeight;

    }

}

***************TiledBg.java

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

import javax.microedition.lcdui.*;

import javax.microedition.lcdui.game.*;

import java.io.IOException;

/**

 * @author Administrator

 */

public class TiledBg {

    private Image tiled;            //贴图源图

    private TiledLayer tiledbg;     //定义贴图层

    int AnimSeq[]={14,21,28};       //动态贴图序列

    int AnimTiled;          //动态贴图号

    int AnimIndex;          //记录当前动态贴图序号

    int AnimTimes;          //用于计算动态贴图时间间隔

    public TiledBg(){

        try {

                // write pre-init user code here

                tiled = Image.createImage("/tiled.png"); //获取源图

            } catch (IOException ex) {

                ex.printStackTrace();

            }

            AnimIndex=0;    //初始化

            AnimTimes=0;

    }

    /* 获取贴图源图像*/

    public Image getTiled()  {

        return this.tiled;

    }

   

    /* 更新动态贴图 */

    public void update(){

        //检测动态贴图时间间隔，每5次循环更新一次动态贴图

        if(AnimTimes%5==0){

            AnimIndex++;        //动态贴图序号递增

                     if(AnimIndex>=AnimSeq.length){  //检查动态贴图序号是否超出下标范围

                            AnimIndex=0;    //重置动态贴图序号

                     }

            //设置动态贴图

                     tiledbg.setAnimatedTile(AnimTiled, AnimSeq[AnimIndex]);

        }

        AnimTimes++;    //动态贴图时间间隔递增

    }

   

    /* 创建并返回动态贴图*/

    public TiledLayer getTiledbg() {

        //检查贴图层是否已创建，如未创建则先创建

        if (tiledbg == null) {

            tiledbg = new TiledLayer(20, 10, tiled, 32, 32);    //创建贴图层

            AnimTiled= tiledbg.createAnimatedTile(AnimSeq [0]);

            //定义贴图序号数组

            int[][] tiles = {

                { 3, 3, 2, 2, 2, 2, 2, 15, 7, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 2 },

                { 2, 2, 2, 2, 2, 4, 2, 15, 2, 2, 2, 2, 2, 6, 2, 2, AnimTiled, 2, 3, 2 },

                { 7, 2, 2, 26, 2, 2, 2, 17, 10, 9, 10, 9, 11, 2, 2, 2, 13, 2, 3, 7 },

                { 9, 9, 9, 9, 11, 19, 2, 2, 2, 2, 2, 2, 15, 2, 12, 2, 8, 9, 9, 9 },

                { 2, 2, 2, AnimTiled, 15, 2, 2, 2, 2, 7, 2, 20, 22, 2, 2, 2, 15, 2, 3, 2 },

                { 4, 2, 2, 2, 17, 10, 9, 10, 9, 24, 10, 9, 18, 2, 2, 2, 15, 2, 3, 4 },

                { 2, 2, 2, 2, 2, 2, 2, 2, 2, 15, 2, 2, 26, 19, 19, 2, 15, 2, 3, 2 },

                { 2, 2, 13, 2, 2, 2, 2, 20, 2, 15, AnimTiled, 2, 2, 19, 19, 3, 15, 3, 3, 2 },

                { 2, 2, 2, 2, 2, 8, 10, 9, 10, 16, 10, 9, 10, 9, 10, 9, 18, 3, 3, 2 },

                { 4, 2, 2, 27, 7, 15, 2, 2, 2, 7, 2, AnimTiled, 2, 2, 4, 2, 2, 6, 3, 2 }

            };

            //通过双重循环设置贴图

            for (int row = 0; row < 10; row++) {

                for (int col = 0; col < 20; col++) {

                    tiledbg.setCell(col, row, tiles[row][col]); //设置贴图

                }

            }

        }

        return tiledbg; //返回贴图

    }

   /* 移动贴图层  */

   public void move(int x,int y){

       //检查是否到达贴图层左边缘，如果是，则设置为紧贴左边缘

        if(tiledbg.getX()>=0 && x>0){

            tiledbg.setPosition(0, tiledbg.getY());

            return;

        }

        //检查是否到达贴图层右边缘，如果是，则设置为紧贴右边缘

        if(tiledbg.getX()<=GameWorld.ScreenWidth-tiledbg.getWidth() && x<0){

            tiledbg.setPosition(GameWorld.ScreenWidth-tiledbg.getWidth(), tiledbg.getY());

            return;

        }

       

        //检查是否到达贴图层上边缘，如果是，则设置为紧贴上边缘

        if(tiledbg.getY()>=0  && y>0){

            tiledbg.setPosition(tiledbg.getX(), 0);

            return;

        }

        //检查是否到达贴图层下边缘，如果是，则设置为紧贴下边缘

        if( tiledbg.getY()<=GameWorld.ScreenHeight-tiledbg.getHeight() && y<0){

            tiledbg.setPosition(tiledbg.getX(), GameWorld.ScreenHeight-tiledbg.getHeight());

            return;

        }

        tiledbg.move(x,y);  //移动贴图层

   }

}