JAVA游戏编程之三----j2me 手机游戏入门开发--俄罗斯方块_3_增加成绩记录

作者：雷神
QQ:38929568
QQ群：28048051JAVA游戏编程（满） 28047782（满） 50761834（忙）  31572546（新）
手机游戏开发职业群51871468（,非从事手机开发者勿进!欢迎测试策划美工程序）

声明：本人发表的代码全部可以用来学习，如果需要作商业用途，请及时与作者联系。

本例为J2SE游戏开发的经典游戏--俄罗斯方块,手机移植版本176*220屏幕手机可用！
记录函数在主midlet类！

工程文件如附件所示，地址如下：方块3

方向键 上下左右ASDW2468都可以游戏,0更换方块,1显示隐藏网格!game over 时5键重新开始，*键退出游戏

游戏图片:

cGame176x220.java 主要绘图类

package code;

//import java.awt.*;
//import java.awt.Canvas;
//import java.awt.event.*;
//import javax.swing.*;
import java.util.Random;
import javax.microedition.lcdui.*;            //写界面所需要的包
/** *//**
 * 俄罗斯方块
 * 高雷
 * 2007年11月30日
 */
public class cGame176x220 extends Canvas implements Runnable
...{
    private Random rand;
    private Thread thread;
    private Graphics    gb;
    private Image        buffer;
    private Image         gameOverImg;                    //游戏结束
    private static final int s_width      = 176;
    private static final int s_height     = 220;
    private static final int s_box_w      = 12;
    private static final int s_box_h      = 12;
    private static final int s_box_w_sum     = 10;        //操作区域宽 格子数
    private static final int s_box_h_sum     = 18;        //操作区域高 格子数
    private static final int offx     = 0;                //
    private static final int offy     = -(s_height-s_box_h_sum*s_box_h);//控制区偏移
    private static final int s_line_between_x = s_box_w * s_box_w_sum;//分割线x位置

    public static final int  UP     = -1;
    public static final int  DOWN     = -2;
    public static final int  LEFT     = -3;
    public static final int  RIGHT     = -4;

    public static final int  init_x         = 3;        //当前方块初始化坐标X
    public static final int  init_y         = 0;        //当前方块初始化坐标y

    public static int     s_box_x                = init_x;    //当前方块坐标X
    public static int     s_box_y                = init_y;    //当前方块坐标Y
    private static int    level                = 1;        //等级
    private static int    success                = 0;        //得分
    private static long goDownDelayTime[]    = //1800;    //下降延迟时间
    ...{
        1000,    900,    800,    700,
        600,    500,    400,
        300,    200,    100
    };
    private static int    level_up            = (int)(goDownDelayTime[0]-goDownDelayTime[level]);        //升级成绩
    private static boolean isShowReseau        = true;        //是否现实网格
    private static short s_next_box            = 0;        //下一个方块编号
    private static short boxColor;                        //当前box的颜色
//    private static final Color gameBG        = new Color( 0x333333 );    //游戏区域背景颜色
    private static final int gameBG            = 0x333333;    //游戏区域背景颜色
//    private static final Color gameColor[]    = new Color[]
    private static final int gameColor[]    = new int[]
    ...{
        0x444444,    //new Color( 0x444444 ),    //网格颜色
        0xEEEEEE,    //new Color( 0xEEEEEE ),    //方块颜色
        0xEE0000,    //new Color( 0xEE0000 ),
        0x00EE00,    //new Color( 0x00EE00 ),
        0x0000EE,    //new Color( 0x0000EE ),
        0xEE00EE,    //new Color( 0xEE00EE ),
        0xEEEE00,    //new Color( 0xEEEE00 ),
        0x00EEEE     //new Color( 0x00EEEE )
    };
    private static final short box_sum[][] = new short[][]    //所有方块图形
    ...{
        ...{ 0x0660, 0x0660, 0x0660, 0x0660 },
        ...{ 0x2222, 0x00F0, 0x2222, 0x00F0 },
        ...{ 0x0264, 0x0630, 0x0264, 0x0630 },
        ...{ 0x0462, 0x0360, 0x0462, 0x0360 },
        ...{ 0x02E0, 0x4460, 0x0740, 0x0622 },
        ...{ 0x0E20, 0x2260, 0x0470, 0x0644 },
        ...{ 0x0464, 0x00E4, 0x04C4, 0x04E0 }
    };

    private static short next_box[] = new short[]...{ 0x0660, 0x0660, 0x0660, 0x0660 };
    private static short box[]          = new short[]...{ 0x0660, 0x0660, 0x0660, 0x0660 };
    private static short map[][];        //地图
    private static short box_state  = 0;//当前BOX的状态//旋转方向
    private static short matrix[][] =    //定义矩阵用来计算出box_sum的方块
    ...{
        ...{ 0x1000, 0x0100, 0x0010, 0x0001 },
        ...{ 0x2000, 0x0200, 0x0020, 0x0002 },
        ...{ 0x4000, 0x0400, 0x0040, 0x0004 },
        ...{ (short)0x8000, 0x0800, 0x0080, 0x0008 }
    };

    public cGame176x220()
    ...{
        setFullScreenMode(true);        //设置游戏为全屏幕模式,该函数只能在支持midp2.0的手机上使用
//        s_width = getWidth();            //得到屏幕尺寸     宽
//        s_height= getHeight();            //得到屏幕尺寸     高
        rand = new Random( System.currentTimeMillis() );
        try
        ...{
            //gameOverImg = Toolkit.getDefaultToolkit().getImage("src/pics/laser.png");
            gameOverImg = Image.createImage("/pics/laser.png");
        }catch(Exception e)...{}
        //setSize( s_width, s_height );    //设置画布
        initGame();                        //游戏初始化
        thread  = new Thread(this);
        thread.start();
    }

    private void initGame()
    ...{
        level        = 1;                //等级
        success        = 0;                //得分
        map     = new short[s_box_h_sum][s_box_w_sum];
        setNextBox();                    //设置下一个BOX
        setBox();                        //将下一个BOX设置成当前BOX
        setGameOver( false );            //恢复游戏
    }

    private void setBox()                //将next_box设置成当前可控制box
    ...{
        box_state         = 0;                                        //box 状态
        s_box_x            = init_x;                                    //当前方块坐标X
        s_box_y            = init_y;                                    //当前方块坐标Y
        boxColor        = s_next_box;                                //设置当前BOX颜色
        System.arraycopy( next_box, 0, box, 0, next_box.length );    //box = next_box
        goDownPreTime     = System.currentTimeMillis();                //设置好当前BOX后 计时
        setNextBox();                                                //设置下一个BOX
        if( !isCanMove() )
        ...{
            setGameOver( true );
        }
    }

    public static boolean isGameOver = false;
    public static long updatas     = 0;
    public static long fps         = 0;
    private long     startTime, beginTime, endTime;
    private long     delay         = 25;
    private long     upTime         = 25;
    public void run()
    ...{
        while ( true )
        ...{
            try
            ...{
                beginTime = System.currentTimeMillis();
                updatas++;
                updata( updatas );
                repaint();
                endTime = System.currentTimeMillis();
                upTime  = endTime-beginTime;
                if( upTime<delay )
                ...{
                    fps = 1000/delay;
                    thread.sleep(delay-upTime);
                }
                else
                    fps = 1000/upTime;
            }catch(Exception e)...{ }
        }
    }
    void setGameOver( boolean _isGameOver )
    ...{
        isGameOver = _isGameOver;
        if( isGameOver )
        ...{
            setRecord( successSort() );
        }
    }
    public void updata( long updatas )
    ...{

    }
    public void update(Graphics g)
    ...{
        paint(g);
    }
    public void paint(Graphics g)
    ...{
        try
        ...{
            if( buffer == null )
            ...{
                buffer = Image.createImage( s_width, s_height );    //设置画布缓冲区
                gb = buffer.getGraphics();                    //得到绘图设备
            }
//            gb.translate( offx, offy );
//            gb.setColor( new Color( 0x0 ) );                //初始化 画布颜色
            gb.setColor( 0x0 );                                //初始化 画布颜色
            gb.setClip ( 0, 0, s_width, s_height);            //初始化 画布区域
            gb.fillRect( 0, 0, s_width, s_height);            //初始化 画布填充
            paintReseau( gb );                                //绘制网格
            paintNextBox( gb );                                //绘制下一BOX
            paintMap( gb );                                    //绘制地图上不可以动BOX
            paintBox( gb, s_box_x, s_box_y );                //绘制当前可控制BOX
//            gb.setColor( new Color( 0xFF3333 ) );            //分割线颜色
            gb.setColor( 0xFF3333 );                        //分割线颜色
            gb.drawLine( s_line_between_x, 0, s_line_between_x, s_height );    //分割线
//            gb.drawString( "FPS:"+fps,             s_line_between_x+10,10 );    //祯数
//            gb.drawString( "等级:"+level,         s_line_between_x+10,30 );    //等级
//            gb.drawString( "得分:"+success,         s_line_between_x+10,50 );    //分数
            gb.drawString( "FPS:"+fps,             s_line_between_x+10, 10, g.TOP|g.LEFT );//祯数
            gb.drawString( "级:"+level,         s_line_between_x+10, 30, g.TOP|g.LEFT );//等级
            gb.drawString( "分:"+success,         s_line_between_x+10, 50, g.TOP|g.LEFT );//分数
            if( isGameOver )
            ...{
//                gb.drawImage( gameOverImg, (getWidth()-offx-gameOverImg.getWidth(null))/2, (getHeight()-gameOverImg.getHeight(null))/2 , null );
//                gb.drawImage( gameOverImg,    s_width>>1, s_height>>1, g.HCENTER|g.VCENTER );
                paintRecord( gb );
            }
//            gb.translate( -offx, -offy );
        }
        catch(Exception e)
        ...{
            System.out.println("err at paint.e====="+e);
        }
//        g.drawImage( buffer, offx, offy, null);                //将画布缓冲区绘制到屏幕//偏移 (2，2)
        g.drawImage( buffer, offx, offy, 0);                //将画布缓冲区绘制到屏幕//偏移 (2，2)
    }

    private void paintReseau( Graphics g )                    //绘制网格
    ...{
        g.setColor( gameBG );
        g.fillRect( 0, 0, s_line_between_x, s_height );
        if( isShowReseau )
        ...{
            g.setColor( gameColor[0] );
            for( int i=0; i<s_line_between_x/s_box_w; i++ )    // |
            ...{
                g.drawLine( i*s_box_h, 0, i*s_box_h, s_height );
            }
            for( int j=0; j<s_height/s_box_h; j++ )            // -
            ...{
                g.drawLine( 0, j*s_box_w, s_line_between_x, j*s_box_w );
            }
        }
    }
    private void paintBox( Graphics g, int off_x, int off_y )
    ...{
        for( int i=0; i<4; i++ )        //行
        ...{
            for( int j=0; j<4; j++ )    //列
            ...{
                if( (box[box_state] & matrix[i][j]) == matrix[i][j] )
                ...{
                    g.setColor( gameColor[ boxColor ] );
                    g.fillRect( (off_x+j)*s_box_w, (off_y+i)*s_box_h, s_box_w, s_box_h );

                    g.setColor( gameBG );
                    g.drawRect( (off_x+j)*s_box_w+1, (off_y+i)*s_box_h+1, s_box_w-2, s_box_h-2 );
                }
            }
        }
        goDown();                        //BOX是否下降
    }
    private void paintNextBox( Graphics g )
    ...{
        int off_x = s_line_between_x+( s_width - s_line_between_x - 4*s_box_w )/2;
        int off_y = s_height/2;

        g.translate( off_x, off_y );
        g.setColor( gameBG );
        g.fillRect( 0, 0, 4*s_box_w, 4*s_box_h );

        if( isShowReseau )                //显示格式
        ...{
            g.setColor( gameColor[0] );
            for( int i=0; i<5; i++ )    // |
            ...{
                g.drawLine( i*s_box_h, 0, i*s_box_h, 4*s_box_h );
            }
            for( int j=0; j<5; j++ )    // -
            ...{
                g.drawLine( 0, j*s_box_w, 4*s_box_w, j*s_box_w );
            }
        }
        for( int i=0; i<4; i++ )        //行
        ...{
            for( int j=0; j<4; j++ )    //列
            ...{
                if( (next_box[0] & matrix[i][j]) == matrix[i][j] )
                ...{
                    g.setColor( gameColor[ s_next_box ] );
                    g.fillRect( j*s_box_w, i*s_box_h, s_box_w, s_box_h );

                    g.setColor( gameBG );
                    g.drawRect( j*s_box_w+1, i*s_box_h+1, s_box_w-2, s_box_h-2 );
                }
            }
        }
        g.translate( -off_x, -off_y );
    }

    private long goDownPreTime     = 0;    //上次下降时间
    private long currTime         = 0;    //当前时间
    private void goDown()                //当前BOX下降
    ...{
        if( isGameOver )    //游戏结束
            return;
        //isKeyDown按了向下移动就需要检查 不需要时间
        if( isKeyDown==1 || System.currentTimeMillis() - goDownPreTime >= goDownDelayTime[level] )
        ...{
            s_box_y++;
            goDownPreTime = System.currentTimeMillis();
            if( !isCanMove() )
            ...{
                isKeyDown = 0;    //没有按下
                s_box_y--;
                setMap();        //将BOX放进map
                setBox();        //新的BOX
            }
        }
    }

    private void setMap()
    ...{
        for( int i=0; i<4; i++ )        //行
        ...{
            for( int j=0; j<4; j++ )    //列
            ...{
                if( ( box[box_state] & matrix[i][j] ) == matrix[i][j] )    //是格子
                ...{
                    map[s_box_y+i][s_box_x+j] = boxColor;
                }
            }
        }
        //检测是否可以消去一行
        int line_success = 0;
        for( int i=0; i<s_box_h_sum; i++ )        //行
        ...{
            if( isFullLine( i ) )                //这行可以消去
            ...{
                setNullLine( i );                //设置第i行为空
                setGoDownMap( i );                //地图第i行以上的向下移动一行
                line_success++;
            }
        }
        success += line_success*line_success;    //设置得分
        level_up = (int)(goDownDelayTime[0]-goDownDelayTime[level]);
        if( success >= level_up )                //设置升级
        ...{
            level %= goDownDelayTime.length;
            level ++;
        }
    }

    private void paintMap( Graphics g )
    ...{
        for( int i=0; i<s_box_h_sum; i++ )        //行
        ...{
            for( int j=0; j<s_box_w_sum; j++ )    //列
            ...{
                if( map[i][j] > 0 )                //是格子//绘制格子
                ...{
                    g.setColor( gameColor[ map[i][j] ] );
                    g.fillRect( j*s_box_w, i*s_box_h, s_box_w, s_box_h );

                    g.setColor( gameBG );
                    g.drawRect( j*s_box_w+1, i*s_box_h+1, s_box_w-2, s_box_h-2 );
                }
            }
        }
    }

    private int successSort()    //成绩排序
    ...{
        for( int i=0; i<Tetris.recoreMax; i++ )
        ...{
            if( success >= Tetris.success[i] )
                return i;
        }
        return Tetris.recoreMax;
    }
    private static int successPlace = 0;    //名次
    private void setRecord(int num)    //设置记录
    ...{
        successPlace = num;
        System.out.println("successPlace="+successPlace);
        for( int i=Tetris.recoreMax-1; i>=0; i-- )
        ...{
            if( i==num )
            ...{
                Tetris.success [i] = success;
                Tetris.dateTime[i] = Tetris.getDate();
            }else
            ...{
                Tetris.success [i] = Tetris.success [i-1];
                Tetris.dateTime[i] = Tetris.dateTime[i-1];
            }
        }
     }
    /////////绘制成绩列表////////////
    private static final int w1     = 45;    //名次 后分隔线
    private static final int w2     = 85;    //成绩 后分隔线
    private static final int font_h = 16;    //字体高度
    private void paintRecord( Graphics g )        //绘制记录
    ...{
        g.setColor( gameBG );
        g.fillRect( 0, 0, s_width, s_height );
        g.setColor( gameColor[1] );                //白色色
        g.drawString("名次",5,2,g.TOP|g.LEFT);
        g.drawString("成绩",w1,2,g.TOP|g.LEFT);
        g.drawString("日期",w2,2,g.TOP|g.LEFT);
        g.setColor( gameColor[0] );                //网格色
        g.drawLine(w1,0,w1,s_height);
        g.drawLine(w2,0,w2,s_height);

        for(int i=1; i<=Tetris.recoreMax; i++ )
        ...{
            if( i == successPlace+1 )
                g.setColor( gameColor[2] );        //红色
            else
                g.setColor( gameColor[1] );        //白色
            g.drawString(""+i,5,font_h*i,g.TOP|g.LEFT);
            g.drawString(""+Tetris.success [i-1],w1, font_h*i, g.TOP|g.LEFT);
            g.drawString(""+Tetris.dateTime[i-1],w2, font_h*i, g.TOP|g.LEFT);
            g.setColor( gameColor[0] );            //网格色
            g.drawLine(0,font_h*i,s_width,16*i);
        }
        g.setColor( gameColor[6] );                //黄色
        g.drawString("5:Replay",s_width>>1,s_height-font_h*2, g.TOP|g.HCENTER);
        g.drawString("*:Exit",    s_width>>1,s_height-font_h*1, g.TOP|g.HCENTER);
    }

    private boolean isFullLine(int line)    //是否一行已经满了
    ...{
        for( int j=0; j<s_box_w_sum; j++ )    //列
        ...{
            if( map[line][j] <= 0 )
            ...{
                return false;
            }
        }
        return true;
    }

    private void  setNullLine( int line )    //设置地图上的这一行 空
    ...{
        for( int j=0; j<s_box_w_sum; j++ )    //列
        ...{
            map[line][j] = 0;
        }
    }
    private void setGoDownMap( int line )    //设置地图line以上的每行都向下移动一行
    ...{
        for( int i=line; i>0; i-- )            //行
        ...{
            for( int j=0; j<s_box_w_sum; j++ )    //列
            ...{
                map[i][j] = map[i-1][j];     //向下移动一行
            }
        }
    }
    private static          int act_off_x     = 0;    //方块在左右边界旋转的时候调整方块位置的偏移
    private static final int act_move     = 0;
    private static final int act_transfiguration = 1;
    private boolean isCanMove()
    ...{
        return isCanMove( act_move );
    }
    private boolean isCanMove( int act )
    ...{
        for( int i=0; i<4; i++ )        //行
        ...{
            for( int j=0; j<4; j++ )    //列
            ...{
                if( ( box[box_state] & matrix[i][j] ) == matrix[i][j] )    //是格子
                ...{
                    if( s_box_x+j < 0 )                    //左边界检测
                    ...{
                        if( act == act_transfiguration )//左边界检测失败 调整 BOX 位置右移动 最多2格
                        ...{
                            act_off_x=1;
                            s_box_x ++;
                            if( isCanMove() )
                            ...{
                                return true;
                            }
                            else
                            ...{
                                act_off_x=2;
                                s_box_x ++;
                                if( isCanMove() )
                                ...{
                                    return true;
                                }
                                else
                                ...{
                                    act_off_x = 0;
                                }
                            }
                        }
                        System.out.println( "left s_box_x="+s_box_x+" matrix["+i+"]["+j+"]="+matrix[i][j]);
                        return false;
                    }
                    if( s_box_x+j > s_box_w_sum-1 )    //右边界检测
                    ...{
                        if( act == act_transfiguration )//右边界检测失败 调整 BOX 位置左移动 最多1格
                        ...{
                            act_off_x = -1;
                            s_box_x --;
                            if( isCanMove() )
                            ...{
                                return true;
                            }
                            else
                            ...{
                                act_off_x = 0;
                            }
                        }
                        System.out.println( "right s_box_x="+s_box_x+" matrix["+i+"]["+j+"]="+matrix[i][j]);
                        return false;
                    }
                    if( s_box_y+i > s_box_h_sum-1 )    //下边界检测
                    ...{
                        System.out.println( "down s_box_y="+s_box_y+" matrix["+i+"]["+j+"]="+matrix[i][j]);
                        return false;
                    }
                    if( map[s_box_y+i][s_box_x+j] > 0 )    //地图格子检测
                    ...{
                        System.out.println( "map s_box_y="+s_box_y+" matrix["+i+"]["+j+"]="+matrix[i][j]);
                        return false;
                    }
                }
            }
        }
        return true;
    }
    private short isKeyDown = 0;    //0没有按下，1按下，2抬起
//    public boolean keyDown(Event evt, int key)
    public void keyPressed( int key )
    ...{
        key = getKeyCode( key );
        switch( key )
        ...{
            case UP:                //顺时针旋转
                isKeyDown = 0;        //0没有按下
                box_state ++;
                box_state %= 4;
//                s_box_x -= act_off_x;    //恢复偏移中心到未偏移前//不恢复的好1
                if( !isCanMove( act_transfiguration ) )
                ...{
                    box_state --;
                    if( box_state<0 )
                        box_state = 3;
                }
            break;
            case DOWN:                //向下移动
                act_off_x = 0;        //恢复BOX旋转位置偏移为0
                if( isKeyDown == 2 )
                    isKeyDown = 1;
                if( isKeyDown == 1 )
                ...{
                    s_box_y ++;
                    if( !isCanMove() )
                        s_box_y --;
                }
            break;
            case LEFT:                //向左移动BOX
                act_off_x = 0;        //恢复BOX旋转位置偏移为0
                isKeyDown = 0;        //0没有按下
                s_box_x --;
                if( !isCanMove() )
                    s_box_x ++;
            break;
            case RIGHT:                //向右移动BOX
                act_off_x = 0;        //恢复BOX旋转位置偏移为0
                isKeyDown = 0;        //0没有按下
                s_box_x ++;
                if( !isCanMove() )
                    s_box_x --;
            break;
            case 53:                //数字5键
                if( isGameOver )    //游戏结束
                    initGame();        //重新游戏
            break;
            case 42:
                if( isGameOver )    //游戏结束
//                    System.exit(0);    //退出游戏
                    Tetris.s_midlet.destroyApp(true);
            break;
            case 48:
                setBox();            //新的BOX
            break;
            case 49:                //是否显示网格
                isShowReseau = !isShowReseau;
            break;
        }
        repaint();                    //重新绘制屏幕
//        return true;
    }
    public void keyRepeated( int key )
    ...{
        keyPressed( key );
    }
    public void setNextBox()
    ...{
        s_next_box = (short)rand.nextInt( box_sum.length );
        System.arraycopy( box_sum[s_next_box], 0, next_box, 0, next_box.length );
        s_next_box++;
    }

    public int getKeyCode( int key )
    ...{
        System.out.println( "key="+key );
        switch( key )
        ...{
            case 1004:     // up
            case 119:     // w
            case 87:     // W
            case 50:     // 2
            return UP;

            case 1005:     // down
            case 115:     // s
            case 83:     // S
            case 56:     // 8
            return DOWN;

            case 1006:     // left
            case 97:     // a
            case 65:     // A
            case 52:     // 4
            return LEFT;

            case 1007:     // right
            case 100:     // d
            case 68:     // D
            case 54:     // 6
            return RIGHT;
            default:
            return key;
        }
    }
//    public boolean keyUp(Event evt, int key)
    public void keyReleased( int key )
    ...{
        isKeyDown = 2;    //释放按键
//        return true;
    }
//    public boolean mouseDown(Event evt, int x, int y)
//    {
//        try
//        {
////            System.out.println( "x="+x+" y="+y );
//        }catch( Exception e){e.printStackTrace();}
////        this.repaint();
//        return true;
//    }
//    public boolean mouseMove(Event evt, int x, int y)
//    {
//        try
//        {
//            //System.out.println( "x="+x+" y="+y );
//        }catch( Exception e){e.printStackTrace();}
//        return true;
//    }
//    public static void main(String[] args)
//    {
//        JFrame frame = new JFrame("俄罗斯方块 北京|雷神 QQ:38929568");
//        final cGame dc = new cGame();
//        frame.getContentPane().add(dc, BorderLayout.CENTER);
//
////        JButton button = new JButton("刷新");
////        button.addActionListener(new ActionListener()
////        {
////            public void actionPerformed(ActionEvent e)
////            {
////                dc.repaint();
////            }
////        });
////        frame.getContentPane().add(button, BorderLayout.SOUTH);
//        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//        frame.setSize(dc.s_width+10, dc.s_height+30);
//        frame.setVisible(true);
//    }
}

Tetris.java 主MIDlet 类

package code;
///////////////////////////////////////////////////////////////////////////////////////////////////
/** *//**
 * 俄罗斯方块
 * 高雷
 * 2007年11月30日
 */
///////////////////////////////////////////////////////////////////////////////////////////////////
import javax.microedition.midlet.*;    //j2me MIDlet程序必须继承MIDlet类，所以要引入此包
import javax.microedition.lcdui.*;    //Display这个类所在包

import javax.microedition.rms.*;
import java.io.*;
import java.util.*;
import java.util.Calendar;
import java.util.Date;
///////////////////////////////////////////////////////////////////////////////////////////////////

public class Tetris extends MIDlet
...{
    static Tetris s_midlet;    //MIDlet类的静态对象，方便实用 MIDlet类方法
    static Display s_display = null;//用来显示 Canvas
    static cGame176x220 s_game = null;        //Canvas类对象，主要实现游戏的类

    public Tetris()
    ...{
        s_midlet = this;
    }

    /** *//**
     * 程序开始 系统会调用这个函数
     * 也有些手机 可以把程序初始化部分放到构造函数里，这连个地方应视手机的不同而定!
     */
    public void startApp()
    ...{
        ReadData();
        if (s_display == null)
        ...{
            s_display = Display.getDisplay(this);//创建Display对象，参数是MIDlet类对象，也就是我们当前写的这个Minesweeper类
        }

        if (s_game == null)
        ...{
            s_game = new cGame176x220();                //创建 Canvas对象
            s_display.setCurrent(s_game);        //把Canvas对象设置成当前显示
        }
        else
        ...{
            s_display.setCurrent(s_game);
        }
    }

    /** *//**
     * 程序暂停 系统会自动调用这个函数,不是所有手机都支持，
     * 手机在接到中断,如 来电,来短信时候会调用这个函数,这个函数 通常是空的！
     */
    public void pauseApp()
    ...{

    }

    /** *//**
     * 程序关闭 系统会调用这个函数,如果希望关闭程序的时候保存数据,可在这个函数里添加保存数据的方法
     * 比如游戏进行中，按了关机键，程序就会调用这个函数，也可以在程序中调用这个函数来结束游戏！
     */
    public void destroyApp(boolean unconditional)
    ...{
        WriteData();
        notifyDestroyed();
    }


    static Calendar    cal        = Calendar.getInstance();
    static Date        date    = null;
    public static String getDate()
    ...{
        date = new Date( System.currentTimeMillis() );
        cal.setTime( date );
        return "" +( cal.get( Calendar.MONTH ) + 1 )+"月"+cal.get( Calendar.DAY_OF_MONTH )+"日"+cal.get( Calendar.YEAR );
    }
    public static String getTime()
    ...{
        date = new Date( System.currentTimeMillis() );
        cal.setTime( date );
        return "_" + cal.get( Calendar.HOUR_OF_DAY ) + "_" + cal.get( Calendar.MINUTE ) + "_"
                + cal.get( Calendar.SECOND );
    }

    public static final String         gameName     = "Tetris";
    public static final int            recoreMax     = 8;
    public static         int[]        success     = new int[recoreMax];
    public static         String[]    dateTime    = new String[recoreMax];
    /** *//**
    * 读取存档记录
    */
    public void ReadData()
    ...{
        String rmsName = gameName;
        try
        ...{
            RecordStore rs = RecordStore.openRecordStore(rmsName, false);    //人物数据
            //<读取人物数据>
            byte[] data = rs.getRecord(1);
            ByteArrayInputStream bais = new ByteArrayInputStream(data);
            DataInputStream in = new DataInputStream(bais);
            for(int i=0; i<success.length; i++ )
            ...{
                success    [i] = in.readInt();                    //分数
                dateTime[i] = in.readUTF();                    //日期
            }
//----------------2.0--------------
            int k;
            k = in.readInt(); // 11备用
            k = in.readInt(); // 12备用
            //</读取人物数据>
        }
        catch (Exception e)    ...{  }//新建档案
    }
    /** *//**
    * 写记录
    */
    public void WriteData()
    ...{
        String rmsName = gameName;
        try
        ...{
            RecordStore rs = RecordStore.openRecordStore(rmsName, true); //如不存在数据库,则创建
            //<写人物数据>
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            DataOutputStream out = new DataOutputStream(baos);
            for(int i=0; i<success.length; i++ )
            ...{
                out.writeInt( success    [i] );             // 分数
                out.writeUTF( dateTime    [i] );             // 日期
            }
//            ----------------2.0--------------
            out.writeInt(0); //11 预留
            out.writeInt(0); //12 预留

            byte[] data = baos.toByteArray(); //转换成byte数组
            if (rs.getNumRecords() != 0)//已经有记录存在
                rs.setRecord(1, data, 0, data.length);
            else
                rs.addRecord(data, 0, data.length);

            out.close();
            baos.close();
            rs.closeRecordStore();
            //</写人物数据>
        }
        catch (Exception e2)...{}
    }
}