mygamewithtiledlayercanvas.java

J2ME

import javax.microedition.lcdui.* ;
import javax.microedition.lcdui.game.* ;
import java.io.*;
public class MyGameWithTiledLayerCanvas extends GameCanvas
implements Runnable
{ 
        /*定义画板*/
        Graphics g;
        /*定义布局管理器*/
        LayerManager lm ;
        /*定义背景图层*/
        TiledLayer b1 ;
        /*定义精灵*/
        Sprite c1 ;
        Sprite c2;
        /*定义Bomb类，用单独的线程控制泡泡的爆炸*/
        Bomb bomb;
        /*己方坦克在地图中的位置*/
        int tank;
        /*对方坦克在地图中的位置*/
        int tank1;
        /*初始化校对值*/
        int WALL=0;
        /*己方坦克的x坐标*/
        int x  ;
        /*己方坦克的y坐标*/
        int y  ;
        /*己方坦克方向初始值*/
        int state = 0 ;
        /*对方坦克方向初始值*/
        int state1=0;
        /*对方坦克x坐标*/
        int ex;
       /*对方坦克y坐标 */
        int ey;
        /*胜负标记初始化*/
        int flag=0;
        /*坦克位置标记初始化*/
        int flag1;
        /*定义输出流以实现数据的输出*/
        OutputStream os;
        /*定义Sender类以操纵数据的输出*/
        Sender sender;
        /*地图数组初始化*/
        int[] map={
                    11,11,3,11,11,3,11,11,11,11,11,                
                    11,11,2,11,3,11,3,2,3,11,3,
                    11,11,3,2,11,11,2,11,11,3,11,
                    3,2,3,11,2,11,11,11,3,11,3,
                    11,11,2,11,3,11,2,11,11,3,11,                
                    11,2,3,11,11,3,11,11,11,11,11,
                    3,11,3,11,3,11,11,2,11,11,11,
                    11,2,3,11,11,11,3,11,3,2,3,                
                    3,11,11,11,11,11,11,3,11,11,11,
                    11,11,11,11,11,2,3,11,11,11,11
                };
        /*这个函数可以实现地图所有图象的初始化*/
        public MyGameWithTiledLayerCanvas(int x1,OutputStream os1)
        {
                super(true) ;;
                flag1=x1;
                /*如果flag1=1就说明己方为服务器，只是对坦克的位置进行初始化*/
                if(flag1==1)
                {x=0;
                 y=0;
                 ex=160;
                 ey=153;
                 tank=0;

              }
              /*flag1!=1就说明己方为客户端了*/
              else 
              {x=160;
               y=153;
               ex=0;
               ey=0;
               tank=109;
              }
              /*初始化输出流为主函数同一个输出流*/
               os=os1;
                sender=new Sender(os);
                lm = new LayerManager() ;
                /*调用构造函数实现地图背景的绘制*/
                b1 = createBackGround() ;
                /*实现坦克的绘制*/
                c1 = createTank("/pic/tank2.png") ;
                c2=createTank("/pic/tank2.png") ;
                /*将所有景象在屏幕上显示出来*/
                lm.append(c1);
                lm.append(c2);
                lm.append(b1);
                
        }
      /*在源图片上切一个16*16大小的小图片作为坦克的景象，返回值为sprite对象*/
        private Sprite createTank(String pic)
        {
                Image img = null ;
                try
                {
                        img = Image.createImage(pic);  
                }catch(Exception exp)
                {
                        System.out.println(exp);
                }
                return new Sprite(img,16,16)  ;
        }
        /*按照地图数组将地图背景初始化*/
        public TiledLayer createBackGround()
        {
                Image img = null;
                try
                {
                        img = Image.createImage("/pic/border.png");
                }catch(Exception exp)
                {
                        System.out.println(exp) ;
                }
                /*地图格子11*10,每格大小16*17*/
                TiledLayer tiledLayer = new TiledLayer(11, 10, img, 16, 17);
                /*将地图格子填充*/
                for (int i = 0; i < map.length; i++)
                {
                        int column = i % 11;
                        int row = (i-column)/ 11;
                        tiledLayer.setCell(column, row, map[i]);
                        
                        //System.out.println(i+";"+column+";"+row);
                }
                return tiledLayer;
        }

       
        /*循环条件初始化*/
        boolean conti = true ;
        /*设定缓冲时间以实现在不同机器上速度同步*/
        int rate = 150 ;
        public void run()
        {
                long st = 0 ;
                long et = 0 ;
                g = getGraphics() ;               
                while(conti)
                {
                        st = System.currentTimeMillis() ;
                       /*
                        *侦测输入，根据不同的输入处理坐标的改变，
                        *状态的改变以及数据的传送
                        */
                        input() ;
                        /*改变坦克的方向*/
                        rotate();
                        tank1=ex/16+(ey/17)*11;
                      /*重绘地图*/
                        render(g) ;
                        /*实现快机时间延缓*/
                        et = System.currentTimeMillis() ;
                        if((et-st)<rate)
                        {
                                try
                                {
                                        Thread.sleep(rate-(et-st));
                                }catch(Exception exp){}
                        }
                }
        }
        /*
                        *侦测输入，根据不同的输入处理坐标的改变，
                        *状态的改变以及数据的传送
         */
        public void input()
        {
         int keystate = getKeyStates() ;
                /*向上键被按下*/
                if((keystate & UP_PRESSED)!=0)
                { 
                   /*坦克格子位的改变*/
                   tank=tank-11;
                   /*判断是否能移动*/
                   if((tank>=0)&&((map[tank]|WALL)!=2)&&((map[tank]|WALL)!=18)
                          &&((map[tank]|WALL)!=3))
                       {    
                        /*坦克当前朝向*/
                        state=3;
                        /*坦克坐标的改变*/
                        y=y-17;
                        //判断上边界
                        if( y <= 0 )
                               y = 0 ; 
                        /*发送改变的一些数据*/
                        sendto(x,y,-1,state);
                        } 
                        else tank=tank+11;     
                      
                }
                /*向下键被按下，下面注解同上*/
                if((keystate & DOWN_PRESSED)!=0)
                {      
                       tank=tank+11; 
                     if((tank<=109)&&((map[tank]|WALL)!=2)&&((map[tank]|WALL)!=18)
                     &&((map[tank]|WALL)!=3))
                        {
                        	state=1;
                        y=y+17;
                        //判断下边界
                        if( y >= 153 )
                                	y = 153 ;
                         sendto(x,y,-1,state);
                         }
                         else tank=tank-11;     
                }
                /*向左键被按下*/
                if((keystate & LEFT_PRESSED)!=0)
                {
                       tank=tank-1;
                     if((tank>=0)&&((map[tank]|WALL)!=2)&&((map[tank]|WALL)!=18)
                     &&((map[tank]|WALL)!=3))
                        {
                        state=2;
                        x=x-16;
                        //判断左边界
                        if( x <0 )
                               { x = 0 ;
                               tank=tank+1;}
                              sendto(x,y,-1,state);
                         } 
                      else tank=tank+1;       
                }
                /*向右键被按下*/
                if((keystate & RIGHT_PRESSED)!=0)
                {
                        tank=tank+1;
                     if((tank<=109)&&((map[tank]|WALL)!=2)&&((map[tank]|WALL)!=18)
                     &&((map[tank]|WALL)!=3))
                        {
                        state=0;
                        x=x+16;
                        //判断右边界
                        if( x >=176 )
                                {x = 160 ;
                                tank=tank-1;}
                       sendto(x,y,-1,state);
                       } 
                     else tank=tank-1;       
                        
                }
                /*回车键被按下*/
                if((keystate&FIRE_PRESSED)!=0)
                {
                	/*在相应位置放下泡泡*/
                	bomb=new Bomb(tank,this);
                	/*泡泡爆炸线程启动*/
                	bomb.start();
                    sendto(x,y,tank,state);
                }
                 
            }
        /*更新地图，放泡泡时被调用*/
        public void updatetile1(int x,int y,int z)
        {int x1,y1,z1,z2;
        x1=x;
        y1=y;
        z1=z;
        /*算出在地图数组中的位置*/
        z2=x1+y1*11;
        /*改变地图数组的相应值*/
        map[z2]=18;
        if(z1==11)
        map[z2]=11;
        b1.setCell(x1,y1,z1);
        }
        /*　更新地图，泡泡爆炸时被调用*/
        public void updatetile(int x,int y,int z)
        {int x1,y1,z1,z2;
        x1=x;
        y1=y;
        z1=z;
        z2=x1+y1*11;
       /*判断泡泡的爆炸范围*/
        if(z2<=109&&z2>=0)
        if(x1>=0&&x1<=10&&y1>=0&&y1<=9&&map[z2]!=2)
        b1.setCell(x1,y1,z1);
       /*判断是否炸到坦克，确定出相应的胜负*/
        if(z2==tank)
          if(flag==2)
            flag=3;
          else if(flag==0)
           flag=1;
        if(z2==tank1)
          if(flag==1)
          flag=3;
          else if(flag==0)
           flag=2;
        if(z2<=109&&z2>=0)
        if(map[z2]==3)
        map[z2]=11;
       }
      /*坦克方向的改变*/
        public void rotate()
        {
                
                setTankDirection(state) ;
                setTankDirection1(state1) ;
        }
        /*具体实现己方坦克方向的改变*/
        public void setTankDirection(int state)
        {
                switch(state)
                {
                        /*坦克方向向右*/
                        case 0 :
                                c1.setFrame(0) ;
                                c1.setTransform(c1.TRANS_ROT90) ;
                                break ;
                        
                        /*坦克方向向下*/
                        case 1 :
                                c1.setFrame(0) ;
                                c1.setTransform(c1.TRANS_ROT180) ;
                                break ;
                        
                        /*坦克方向向左*/
                        case 2 :
                                c1.setFrame(0) ;
                                c1.setTransform(c1.TRANS_ROT270) ;
                                break ;
                       /*坦克方向向上*/
                        case 3 :
                                c1.setFrame(0) ;
                                c1.setTransform(c1.TRANS_NONE) ;
                                break ;
                        
                }
        }
/*  具体实现对方坦克方向的改变,具体实现同上 */      
        public void setTankDirection1(int state1)
        {
                switch(state1)
                {
                        
                        case 0 :
                                c2.setFrame(0) ;
                                c2.setTransform(c2.TRANS_ROT90) ;
                                break ;
                        
                        case 1 :
                                c2.setFrame(0) ;
                                c2.setTransform(c2.TRANS_ROT180) ;
                                break ;
                        
                        case 2 :
                                c2.setFrame(0) ;
                                c2.setTransform(c2.TRANS_ROT270) ;
                                break ;
                        case 3 :
                                c2.setFrame(0) ;
                                c2.setTransform(c2.TRANS_NONE) ;
                                break ;
                        
                }
        }
        /*更新地图*/
        public void render(Graphics g)
        {
                /*设置己方坦克的位置*/
                c1.setPosition(x,y);
                /*设置对方坦克的位置*/
                c2.setPosition(ex,ey);                
                /*设置显示的大小*/
                lm.setViewWindow(0,0,180,177);
                /*从屏幕的左上角开始绘制*/
                lm.paint(g,0,0);
                flushGraphics() ;
        }
        /*封装数据并传送*/
        public void sendto(int x1,int y1,int z1,int w1)
        {
        int x2=x1;
        int y2=y1;
        int z2=z1;
        int w2=w1;
        /*将所有的数据封装在一个字符串里面*/
        String s3="";
        s3=s3+x2;
        s3=s3+":";
        s3=s3+y2;
        s3=s3+";";
        s3=s3+z2;
        s3=s3+",";
        s3=s3+w2;
        sender.send(s3);
       }  
/* 负的绘制*/
        public void die1()
       {
       	g.setColor(0xff0000) ;
       	g.drawString("YOU   LOST",70,80,0) ;
       //System.out.println("die1");
        flushGraphics() ;
         conti = false ;
      }
      /*胜的绘制*/
       public void die2()
       { 
       	g.setColor(0xff0000) ;
       	g.drawString("YOU   WIN",70,80,0) ;
       	//System.out.println("die2");
        flushGraphics() ; 
         conti = false ;
      }
     /*和的绘制*/
      public void die3()
       { 
       	g.setColor(0xff0000) ;
       	g.drawString("   DOGFALL   ",70,80,0) ;
        flushGraphics() ; 
         conti = false ;
      }
        /*外部以控制此线程的开始*/
        public void start()
        {
                Thread t = new Thread(this) ;
                t.start();
        }
        public void exit()
        {
                conti = false ;
        }
}