自己乱编的一段网络游戏代码，有兴趣的可以来完善修改

前不久耍了下网络游戏“泡泡堂”，觉得还可以。于是就试着在手机模拟器上实现，现在游戏在wtk2.1下已经可以简单耍耍，可是还极不完全。
由于最近找工作忙，所以没时间再做下去了，希望有兴趣的朋友可以来改改。
游戏希望继续处：　　　　　
1：游戏规则还很简单，希望加入更多的因素。
2：画面很粗糙，动作还不够流畅，在画面上有所完善。
3：现在这个游戏还只能在两台电脑的手机模拟器上玩。希望能建立个服务器，实现多人玩耍。

暂时只有这三点，下面是游戏代码，有6个类，如果要图片的可以给出邮箱．（精灵大小为16*16,地图格子大小为16*16,图片为杂凑，只能作为参考）：
/* ****************************************************************** 
GameMIDlet类，主类：
*********************************************************************/
import javax.microedition.midlet.* ;
import javax.microedition.lcdui.* ;
public class GameMIDlet extends MIDlet
implements CommandListener
{
        /*定义舞台*/
        Display display ;
        private Server server;
        private Client client;
        private static final String SERVER = "Server";
        private static final String CLIENT = "Client";
        /*定义选择画面*/
        private static final String[] names = {SERVER, CLIENT};
        private Form f;
        private ChoiceGroup cg;
        Command c1,exitCommand;
        public GameMIDlet()
        {       exitCommand = new Command("exit", Command.EXIT,2);
                 c1=new Command("结束", Command.EXIT, 1);
                display = Display.getDisplay(this) ;
        }
        /*初始化选择画面*/
        public void begin()
        { f = new Form("泡泡车");
                        cg = new ChoiceGroup("请选择类型",Choice.EXCLUSIVE, names, null);
                        f.append(cg);
                        f.addCommand(new Command("开始", Command.OK, 1));
                        f.addCommand(c1);
                        f.setCommandListener(this);
                        display.setCurrent(f);
        }
        public void startApp()
        {
         begin();              
                
        }
        /*按键事件监听*/
        public void commandAction(Command c,Displayable s)
        {
                String cmd = c.getLabel() ;
                if(cmd.equals("开始"))
                {
                  String name = cg.getString(cg.getSelectedIndex());
                  if (name.equals(SERVER)) {
                   server = new Server(this);
                   server.start();
                }
                else {
             client = new Client(this);
                client.start();
            }
            }else if(cmd.equals("结束"))
                {
                        notifyDestroyed() ;
                }
               else if(cmd.equals("Exit"))
          {if (server != null) {
                    server.stop();
                    }
                if (client != null) {
                    client.stop();
                }
                begin();
            }

        }
        public void pauseApp()
        {

        }
        public void destroyApp(boolean unconditional)
        {
        }
}

146 个解决方案

#1

/********************************************************************
Server类，服务器端类：
*********************************************************************/
import javax.microedition.midlet.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import java.io.*;
public class Server implements Runnable, CommandListener{
    /*定义舞台*/
    Display display;
    /*定义父类，以供传递控制*/
    GameMIDlet parent;
    /*定义服务器端开发的监听端口*/
    ServerSocketConnection scn;
    /*端口连接控制*/
    SocketConnection sc;
    /*定义输入流，以接收客户端传来的数据*/
    InputStream is;
    /*定义输出流，以向客户端发送数据*/
    OutputStream os;
    /*定义游戏控制类，以便实现游戏的初始化和控制*/
    MyGameWithTiledLayerCanvas t;
/*标记传输是否结束*/
boolean stop;
/*定义画板*/
Graphics h;
   /*定义个Alert以显示版本等信息*/
    Alert al;
    Command exitCommand=new Command("Exit", Command.EXIT, 1);
     Command exitCommand1=new Command("结束", Command.EXIT, 1);
    public Server(GameMIDlet m)
{
 parent=m;
 /*得到父类舞台*/
 display = Display.getDisplay(parent);
/*对Alert进行设置*/
al = new Alert("Socket Server");
al.setType(AlertType.INFO);
al.setTimeout(Alert.FOREVER);
al.setString("-------------------------------------"
   +"版权所有（C）2004　...           　　"
            +"作者:王勇　　　　　                  "
            +"学校:SWUST                           "
            +"编写日期:2004/05/29                  "
            +"整理日期:2004/06/19                  "
            +"-------------------------------------"
            );
al.addCommand(exitCommand);
al.setCommandListener(this);
display.setCurrent(al);
}
public void start() {
        /*线程*/
        Thread t = new Thread(this);
        t.start();
    }
public void run()
{
try{
/*服务器常驻5000端口*/
scn = (ServerSocketConnection) Connector.open("socket://:50000");
        /*控制与前来请求的客户端建立连接*/
            sc = (SocketConnection) scn.acceptAndOpen();
       /*打开输入流*/
       is = sc.openInputStream();
            /*打开输出流*/
            os = sc.openOutputStream();
        /*以传递值开始游戏*/
        t=new MyGameWithTiledLayerCanvas(1,os);
            t.addCommand(exitCommand1);
            t.setCommandListener(this);
            display.setCurrent(t);
        t.start();
            /*不停地对数据进行接收并解析之，直到游戏结束*/
            while(true)
            {
              /*将字节流转化为数据流*/
              DataInputStream dis = new DataInputStream(is) ;
                String sb="";
                int c=0;
                /*对数据的一次读入*/
                while (((c = is.read()) != '\n') && (c != -1)) {
                    sb=sb+(char)c;
                }
                if (c == -1) {                    
                    break;
                }
                /*数据解析还原*/
                String sb1="",sb2="",sb3="",sb4="";
                int size=sb.indexOf(":");
                int size1=sb.indexOf(";");
                int size2=sb.indexOf(",");
                for(int i=0;i<size;i++)
                sb1=sb1+sb.charAt(i);            
             for(int i=size+1;i<size1;i++)
             sb2=sb2+sb.charAt(i);
             for(int i=size1+1;i<size2;i++)
             sb3=sb3+sb.charAt(i);
             for(int i=size2+1;i<sb.length();i++)
             sb4=sb4+sb.charAt(i);
             Integer x1 = Integer.valueOf(sb1);
             int x2 = x1.intValue();
             x1=Integer.valueOf(sb2);
             int y2=x1.intValue();
                 x1 = Integer.valueOf(sb3);
             int z2 = x1.intValue();
                x1 = Integer.valueOf(sb4);
             int w2 = x1.intValue();
               /*设置游戏控制部分的某些值以实现画面的互动*/
                t.ex=x2;
                t.ey=y2;
                t.state1=w2;
                /*如果客户端的某个位置安了泡泡，服务器端也要安*/
                if(z2!=-1)
                {Bomb bomb=new Bomb(z2,t);
                 bomb.start();
                }
            } 
           /*当游戏结束，对相应资源的回收*/
           t.exit();
           stop();
           parent.notifyDestroyed();
    } 
    catch (IOException ioe) {

                if (!stop) {
                    ioe.printStackTrace();
                }
            }
 catch (Exception e) {
            e.printStackTrace();
        }
    }        
        /*对一些按纽事件的处理*/
         public void commandAction(Command c, Displayable s) {
          String cmd =c.getLabel();
          if(cmd.equals("Exit")){
          parent.notifyDestroyed();
            parent.destroyApp(true);
        }
        else if(cmd.equals("结束")){
           t.exit();
           stop();
           parent.notifyDestroyed();
        }
    }
     /*资源的回收*/
     public void stop() {
        try {
            stop = true;

            if (is != null) {
                is.close();
            }

            if (os != null) {
                os.close();
            }

            if (sc != null) {
                sc.close();
            }

            if (scn != null) {
                scn.close();
            }
        } catch (IOException ioe) {}
    }
}

#2

/********************************************************************
Client类，客户器端类：
*********************************************************************/
import javax.microedition.midlet.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import java.io.*;
public class Client implements Runnable,CommandListener{
    /*定义舞台*/
    Display display;
    /*定义父类，以供传递控制*/
    GameMIDlet parent;
   /*端口连接控制*/
    SocketConnection sc;
   /*定义输入流，以接收服务器端传来的数据*/ 
    InputStream is;
     /*定义输出流，以向服务器端发送数据*/
    OutputStream os;
     /*定义游戏控制类，以便实现游戏的初始化和控制*/
    MyGameWithTiledLayerCanvas t;
/*标记传输是否结束*/
boolean stop;
/*定义画板*/
Graphics h;
 /*定义个Alert以显示版本等信息*/
Alert al;
Command exitCommand=new Command("Exit", Command.EXIT, 1);
     Command exitCommand1=new Command("结束", Command.EXIT, 1);
public Client(GameMIDlet m)
{
 parent=m;
 /*得到父类舞台*/
 display = Display.getDisplay(parent);
 /*对Alert进行设置*/
 al = new Alert("Client Server");
 al.setType(AlertType.INFO);
al.setTimeout(Alert.FOREVER);
al.setString("-------------------------------------"
        +"版权所有（C）2004　...           　　"
            +"作者:王勇　　　　　                  "
            +"学校:SWUST                           "
            +"编写日期:2004/05/29                  "
            +"整理日期:2004/06/19                  "
            +"-------------------------------------"
            );
al.addCommand(exitCommand);
al.setCommandListener(this);
display.setCurrent(al);
}
public void start() {
         /*线程*/
        Thread t = new Thread(this);
        t.start();
    }
public void run()
{
try{
  /*控制与服务器端建立连接*/
 sc = (SocketConnection) Connector.open("socket://localhost:50000");
/*打开输入流*/
        is = sc.openInputStream();
            /*打开输出流*/
            os = sc.openOutputStream();
        /*以传递值开始游戏*/
            t=new MyGameWithTiledLayerCanvas(2,os);
             t.addCommand(exitCommand1);
            t.setCommandListener(this);
            display.setCurrent(t);
        t.start();
            /*不停地对数据进行接收并解析之，直到游戏结束*/
            while(true)
            {
               /*将字节流转化为数据流*/
              DataInputStream dis = new DataInputStream(is) ;
                String sb="";
                int c=0;
                /*对数据的一次读入*/
                while (((c = is.read()) != '\n') && (c != -1)) {
                    sb=sb+(char)c;
                
                }
                if (c == -1) {
                    System.out.println("client 49");
                    break;
                }
                 /*数据解析还原*/
                String sb1="",sb2="",sb3="",sb4="";
                int size=sb.indexOf(":");
                int size1=sb.indexOf(";");
                int size2=sb.indexOf(",");
                for(int i=0;i<size;i++)
                sb1=sb1+sb.charAt(i);            
             for(int i=size+1;i<size1;i++)
             sb2=sb2+sb.charAt(i);
             for(int i=size1+1;i<size2;i++)
             sb3=sb3+sb.charAt(i);
             for(int i=size2+1;i<sb.length();i++)
             sb4=sb4+sb.charAt(i);
             Integer x1 = Integer.valueOf(sb1);
             int x2 = x1.intValue();
             x1=Integer.valueOf(sb2);
             int y2=x1.intValue();
                 x1 = Integer.valueOf(sb3);
             int z2 = x1.intValue();
                x1 = Integer.valueOf(sb4);
             int w2 = x1.intValue();
                 /*设置游戏控制部分的某些值以实现画面的互动*/
                t.ex=x2;
                t.ey=y2;
                t.state1=w2;
                /*如果服务器端的某个位置安了泡泡，服务器端也要安*/
                if(z2!=-1)
                {Bomb bomb=new Bomb(z2,t);
                 bomb.start();
                }
             } 
             /*当游戏结束，对相应资源的回收*/
             t.exit();
           stop();
           parent.notifyDestroyed();
    } 
    catch (IOException ioe) {

                if (!stop) {
                    ioe.printStackTrace();
                }
            }
 catch (Exception e) {
            e.printStackTrace();
        }
    }        
  /*对一些按纽事件的处理*/
public void commandAction(Command c, Displayable s) {
          String cmd =c.getLabel();
          if(cmd.equals("Exit")){
          parent.notifyDestroyed();
            parent.destroyApp(true);
        }
        else if(cmd.equals("结束")){
           t.exit();
           stop();
           parent.notifyDestroyed();
        }
    }
/*资源的回收*/
public void stop() {
        try {
            stop = true;

            if (is != null) {
                is.close();
            }

            if (os != null) {
                os.close();
            }

            if (sc != null) {
                sc.close();
            }
        } catch (IOException ioe) {}
    }
}
/********************************************************************
Sender类，传输共用类：
*********************************************************************/

import javax.microedition.midlet.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import java.io.*;

public class Sender extends Thread {

    private OutputStream os;
    private String message;

    public Sender(OutputStream os) {
        /*得到父类的输出流*/
        this.os = os;
        start();
    }

    public synchronized void send(String msg) {
        /*得到父类的传输值*/
        message = msg;
        notify();
    }

    public synchronized void run() {

        while(true) {

            /*如果传输的数据没有被接收，则等待*/
            if (message == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

            if (message == null) {
                break;
            }
/*利用输出流传出数据，如果传到了目的端，则结束传输*/
            try {
                os.write(message.getBytes());
               os.write("\n".getBytes());
               stop();
             } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            /* 标记，以用来重新传输*/
           message = null;
        }
    }
/*结束传输*/
    public synchronized void stop() {
        message = null;
        notify();
    }
}

#3

/********************************************************************
Bomb类，爆炸控制类：
*********************************************************************/
public class Bomb extends Thread {
/*初始化炸弹延迟爆炸时间*/
int islow=4000;
/*初始化炸弹爆炸显示时间*/
int isleep=1000;
MyGameWithTiledLayerCanvas t;
int x,x1,x2;
boolean stopmark=false;
public Bomb(int tank,MyGameWithTiledLayerCanvas k)
{
  t=k;
  /*泡泡将放在地图数组的具体位置处*/
  x=tank;
   /*转换为列数*/
   x1=x%11;
   /*转换为行数*/
   x2=x/11;
 }
  public void run()
  {
  while(!stopmark)
  {
   try{
   t.flag=0;
   /*改变放泡泡处的背景图案*/
   t.updatetile1(x1,x2,1);
   sleep(islow);
   /*显示泡泡爆炸时的效果*/
   t.updatetile(x1-1,x2,1);
   t.updatetile(x1+1,x2,1);
   t.updatetile(x1,x2-1,1);
   t.updatetile(x1,x2+1,1);
   t.updatetile(x1,x2,1);
   sleep(isleep);
   /*泡泡爆炸后效果*/
   t.updatetile1(x1,x2,11);
   t.updatetile(x1-1,x2,11);
   t.updatetile(x1+1,x2,11);
   t.updatetile(x1,x2-1,11);
   t.updatetile(x1,x2+1,11);
   /*对方胜，调用相应函数*/
   if(t.flag==1)
    t.die1();
    /*己方胜，调用相应函数*/
    else if(t.flag==2)
    t.die2();
     /*双方平局，调用相应函数*/
     else if(t.flag==3)
      t.die3();
   stopmark=true;
  }
  catch(InterruptedException e){System.out.println("Bomb 37");}
 }
}
}
/*
 *还有个类，太长了，等有人回了再传上来
 */

#4

[e-mail]

谢谢

#5

/********************************************************************
MyGameWithTiledLayerCanvas类，游戏控制类：
*********************************************************************/
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){}
                        }
                }
        }

#6

/*
                        *侦测输入，根据不同的输入处理坐标的改变，
                        *状态的改变以及数据的传送
         */
        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) ;
        }
        /*具体实现己方坦克方向的改变*/

#7

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

#8

我现在也要搞这个.我的电子邮箱是[e-mail]

#9

打个包发给我吧，谢谢
[e-mail]

#10

我很感兴趣，楼主能不能给我发一份：
[e-mail]

#11

me too [e-mail]谢谢

#12

up

#13

[e-mail]

#14

[e-mail]
谢谢楼主，我也是做j2me的：）
不过现在支持wtk2.1的手机不多啊

#15

我也是做J2ME的
谢谢：）[e-mail]

#16

向搂主致敬!万分感谢！！
[e-mail]

#17

向搂主致敬!
[e-mail]

#18

我把整个文件夹都发给你们。自己在wtk2.1下运行，如果有什么问题或有什么改良地方请上来说说．

收到后也上来up一下．

#19

还没收到，热切期待中，谢谢楼主先！！

#20

楼主，
我好想要一份啊。
[e-mail]
谢谢楼主先

#21

现在我给你们都发了，去看一下，没收到的上来说一下。

#22

thanks to yg1982(游)
Would you like to give me a copy?
Maybe I could make some suggestions.
Email:[e-mail]

#23

[e-mail]

谢谢！

#24

楼主,算我一份,谢谢:
[e-mail]

#25

Coooool，已经收到，多谢楼主~~正在研究中。。。Many Thanks!

#26

楼主：

看来我们是一个学校的哟；你厉害，

我现在做WAP方面的，

留个联系方式，因为我们都是：SWUST学校的

#27

[e-mail]
thank you!

#28

to all:
邮件我都发了，没收到的说一下。
to niyboy(JAVA爱好者):
我正在找工作中，准备在成都干。唉，现在本科生找工作难啊。我快要离校了，暂时就在这上面联系。

#29

楼主，源代码已收到，谢谢。有问题再和你联系，大家一起进步。

#30

楼主大功无私啊！为中国游戏业献身！
佩服佩服啊！！！！
想向你学习！！

支持楼主的想法！！
您的代码我在调试中，做进一步的修改！
楼主的图片可以发给我吗？
我的邮箱是：[e-mail]
谢谢了！为中国的游戏业加油

#31

一般吧

#32

[e-mail]

#33

[e-mail]

thanks!

#34

楼主，我也要啊
我的邮箱
[e-mail]
谢谢了哦

#35

收到了，呵呵，谢谢

#36

UP
谢谢楼主：）收到

#37

[e-mail]

#38

上面的都发了。
大家随便改啊，有什么小问题都可以说一下，谢谢大家了。

#39

能不能给我发一个，十分感谢!!
[e-mail]

#40

[e-mail]

#41

楼主真牛啊，我是成都J2ME爱好者
也给个给我吧：[e-mail]

#42

[e-mail]
谢谢~

#43

能发一个给我吗?
[e-mail]

#44

收到了，谢谢楼主

#45

收到了，谢谢楼主~~

#46

在手机模拟器上实现，现在游戏在wtk2.1下运行

对这个比较感兴趣，使开发手机游戏吧，谁能讲讲这方面的东西。

#47

楼主，你好，可以给我发一份吗，
[e-mail]

#48

楼主也给我发一份吧!谢谢了！鞠躬了！
[e-mail]

#49

ME TOO.摟主你是好人 。[e-mail]

#50

谢谢！你讲的很细，但是我以前的接触还不能吸收你的这些知识。

换个问法：如果我写了一个非常简单的手机应用程序，是直接就能插入一款手机里，还是要找一家比较小的公司（如：50万元以下）就可以，还是必须找那些大公司，得到他们的认可，才能在手机生产的某个阶段注入整个程序里。个人写的程序是现在就能，或者2～3年内就能得到手机操作系统的方便支持，就像windows支持应用程序？