码迷,mamicode.com
首页 > 其他好文 > 详细

基于51的俄罗斯方块

时间:2014-06-21 08:24:31      阅读:236      评论:0      收藏:0      [点我收藏+]

标签:style   class   blog   code   tar   ext   

//variable.h 定义该程序用到的全局变量

#ifndef _VARIABLE_H
#define _VARIABLE_H #define GAME_BOARD_WIDTH 50 #define GAME_BOARD_HEIGHT 64 #define PIXEL_PER_CUBE_X 5//4 #define PIXEL_PER_CUBE_Y 4//3 #define NEXT_CUBES_SHOW_POS_X 11 #define NEXT_CUBES_SHOW_POS_Y 9 #define CUBE_COUNT_X 10 #define CUBE_COUNT_Y 16 #define WALL_LOC (GAME_BOARD_WIDTH - 1) //command #define MOVE_LEFT 0x80 #define MOVE_RIGHT 0x40 #define MOVE_DOWN 0x20 #define ROTATION 0x10 #define NO_ACTION 0x01 #define PAUSE 0x02 #define QUIT 0x04 #define CONFIRM 0x08 //level #define LEVEL0 40 //2s #define LEVEL1 20 //1s #define LEVEL2 10 //0.5s #define LEVEL3 7 // #define LEVEL4 5 // #define LEVEL5 3 // typedef unsigned char uchar; typedef unsigned int uint; typedef unsigned long ulong; unsigned char command = NO_ACTION; unsigned char game_score = 0; unsigned char game_score_str[4] = {0}; unsigned char game_score1 = 0; unsigned char game_score2 = 0; unsigned char game_score3 = 0; xdata unsigned int game_board_cube[16] = {0}; xdata unsigned int snake_game_board_cube[16] = {0}; xdata unsigned char highest_cube_per_column[CUBE_COUNT_X] = {0}; unsigned char game_level = LEVEL5; unsigned char real_game_level = 2; typedef struct _Cubes { unsigned char x1, y1; unsigned char x2, y2; unsigned char x3, y3; unsigned char x4, y4; unsigned char cube_type; unsigned char signature; }Cubes; Cubes prev_cubes = {0}; Cubes curr_cubes = {0}; Cubes next_cubes = {0}; #endif

//main.c 主函数
//#include "t6963.c"
#include "variable.h"
#include "teric.c"
//产生随机数
//#define RAND_MAX 32767

unsigned int time = 0;
bit start_count = 1;


/*
* 功  能:定时器0的初始化
* 参  数:无
* 返回值:无
*/
void Timer_Init(void)
{
    EA = 0;
    TMOD=0x11;                 //采用的是定时器0,工作与模式1
    TH0=(65536-46080)/256;    //每隔50ms发起一次中断。
    TL0=(65536-46080)%256;    //50000*11.0592/12 
    
    TR0=1;                     //启用定时器
    ET0=1;                     //开定时器0中断

    TR1=1;
    ET1=1;

    EA=1;                     //开总中断
}

void Timer0_Stop(void)
{
    TR0=0;                     //启用定时器    
    ET0=0;                     //开定时器0中断
//    EA=0;                     //开总中断
}

/*
* 功  能:定时器0的中断处理
* 参  数:无
* 返回值:无
*/
void Time0_Int() interrupt 1
{
    TH0 = (65536-46080) / 256;
    TL0 = (65536-46080) % 256;
    
    if (start_count == 1)
        time ++;
    if (time == game_level)
    {
        Timer0_Stop();
    }
    //    t++;
}

/*
* 功  能:定时器1的中断处理
* 参  数:无
* 返回值:无
*/
void Time1_Int() interrupt 3
{
    TH1 = (65536-46080) / 256;
    TL1 = (65536-46080) % 256;
    
//    if (start_count == 1)
//        time ++;
//    if (time == game_level)
//    {
//        Timer0_Stop();
//    }
    //    t++;
}


#define KEY_DATA        XBYTE[0x0F700]        // 数据口
void KeyDown()
{
    //写行
    uchar sel_row;
    uchar sel_col;
    sel_row = 0x0FE;
    KEY_DATA = sel_row;
    sel_col = KEY_DATA & 0x0f0;
    
    if (sel_col == 0xE0)
    {
    //    LCM_print_ram(9, 1, "LEFT");

        command = MOVE_LEFT;
        return;
    //    move_left = MOVE_LEFT;
     //    move_right = NO_ACTION;
    //    move_down = NO_ACTION;
    //    rotation = NO_ACTION;
    }
//    else if (sel_col == 0xD0)
//    {
//        LCM_print_ram(9, 1, "8");
//    }
//    else if (sel_col == 0xB0)
//    {
//        LCM_print_ram(9, 1, "4");
//    }
    else if (sel_col == 0xB0)
    {
    //    LCM_print_ram(9, 1, "CONFIRM");
        command = CONFIRM;
        return;
    }
    else if (sel_col == 0x70)
    {
        LCM_print_ram(3,7,"Level 0");
        game_level = LEVEL0;
        return;
    }
    
    sel_row = 0x0FD;

    KEY_DATA = sel_row;
    sel_col = KEY_DATA & 0x0f0;
    
    if (sel_col == 0xE0)
    {
    //    LCM_print_ram(9, 1, "DOWN");
        command = MOVE_DOWN;
        return;
    }
    else if (sel_col == 0xD0)
    {
        command = ROTATION;
        return; 
    }
    else if (sel_col == 0xB0)
    {
    //    LCM_print_ram(9, 1, "PAUSE");
        command = PAUSE;
        return;
    //    command = CANCLE;
    }
    else if (sel_col == 0x70)
    {
        LCM_print_ram(3,7,"Level 1");
        game_level = LEVEL1;
        return;
    }


    sel_row = 0x0FB;
    KEY_DATA = sel_row;
    sel_col = KEY_DATA & 0x0f0;
    
    if (sel_col == 0xE0)
    {
        command = MOVE_RIGHT;
        return;
    }

    else if (sel_col == 0xB0)
    {
        LCM_print_ram(9, 1, "QUIT");
        command = QUIT;
        return;
    }

    else if (sel_col == 0x70)
    {
        LCM_print_ram(3,7,"Level 2");
        game_level = LEVEL2;
        return;
    }
}

void main()
{
//    uchar x1, x2, x3, x4, y1, y2, y3, y4;
    //uchar x, y;
    bit which_buff = 0;
//    uint tmp = 0;
    uchar cube_type = 15;
    uchar next_cube_type = 0;
    bit flag = 0;
    bit full_row_flag = 0;
    bit game_over_flag = 0;
    uchar rand_num;


    LCM_init();
    LCM_clear_text();
    LCM_clear_graph1();
    LCM_clear_ram();
//    game_level = LEVEL5;

label_start_game:
    GameMainScreen(command, game_over_flag);
    for (;;)
    {
        KeyDown();
        //默认等级
        if (command == CONFIRM)
        {
            LCM_clear_text();
            LCM_clear_graph1();
            LCM_clear_ram();
            command = NO_ACTION;
            PrintMyInfo();
            game_level = LEVEL5;
            Timer_Init();

            goto label_start_play_game;
        }
        //选择等级
        else if (game_level == LEVEL0 || game_level == LEVEL1 || game_level == LEVEL2)
        {
            LCM_clear_text();
            LCM_clear_graph1();
            LCM_clear_ram();
            if(game_level == LEVEL0)
            {
                LCM_print_ram(3,5,"You Select");
                LCM_print_ram(3,6,"Level 0");
            }
            else if (game_level == LEVEL1)
            {
                LCM_print_ram(3,5,"You Select");
                LCM_print_ram(3,6,"Level 1");
            }
            else if(game_level == LEVEL2)
            {
                LCM_print_ram(3,5,"You Select");
                LCM_print_ram(3,6,"Level 2");
            }
            DelayMs(500);
            command = NO_ACTION;
            LCM_clear_text();
            PrintMyInfo();
            Timer_Init();
            goto label_start_play_game;
        }
    }
    
    while(1);



label_start_play_game:
//    command = NO_ACTION;
    DrawWall();
    //游戏开始之前检测每个柱子的最大高度
    GetHightCubePerColumn();
    //随机生成一个cubes
    rand_num = TL1 % 18;
    cube_type = rand_num;
    curr_cubes = InitCubes(cube_type);
    //在game_board_cubes置1
    SetCubes(game_board_cube, 1);
    //绘制cubes
    DrawTericCubes(curr_cubes);
//    
//    DrawNums(SCORE_NUM_POS_X, SCORE_NUM_POS_Y - NUM_HEIGHT, game_level);
    DrawScore();
    //提示下一个cubes    
    rand_num = TL1 % 18;
    next_cube_type = rand_num;
    next_cubes = InitCubes(next_cube_type);
    ShowNextCubes();


label_play_game:
    for(;;)
    {

        KeyDown();
        if (command == PAUSE)
        {
            command = NO_ACTION;
            goto label_stop_game;
        }
            
        if (command == QUIT)
        {
            command = NO_ACTION;
            goto label_quit_game;
        }
        rand_num = TL1 % 18;
        //每隔一定的时间显示界面
        if (time == game_level)
        {
            start_count = 0;

            //判断当前cubes是否能够再降落下来
            if(curr_cubes.y1 < highest_cube_per_column[curr_cubes.x1] &&
               curr_cubes.y2 < highest_cube_per_column[curr_cubes.x2] &&
               curr_cubes.y3 < highest_cube_per_column[curr_cubes.x3] &&
               curr_cubes.y4 < highest_cube_per_column[curr_cubes.x4])
            {
                //保存上一次的cubes状态,
                //由于在cubes下降过程中,要将之前的cubes清除
                //所以通过保存上一次的cubes可以实现对先前cubes的清除
                prev_cubes = curr_cubes;
                //在game_board_cubes中间先前的cubes位置置0
            //    ResetPrevCubes();
                SetCubes(game_board_cube, 0);
                
                //绘制之前的cubes,实际上是清除cubes
            //    DrawPrevCubes();
                DrawTericCubes(prev_cubes);
                
                //当前cubes的高度下降,默认情况就应该是如此
                curr_cubes.y1 ++;

                //有按键按下
                if (command == MOVE_LEFT || command == MOVE_RIGHT || command == MOVE_DOWN || command == ROTATION)
                {
                    MoveCommand(command );
                    command = NO_ACTION;
                }

                //更新整个cubes的位置
                UpDateCurrCubesPos(&curr_cubes);
                //在game_board_cubes将当前cubes的位置置1
                SetCubes(game_board_cube, 1);
                //绘制当前cubes,并显示出来
                DrawTericCubes(curr_cubes);
            }
            //当前的cubes已经不能再下降
            else 
            {
                //判断是否有一整行全都是cubes的
                //如果有则清除该行
            /*    if (command == MOVE_LEFT || command == MOVE_RIGHT || command == MOVE_DOWN || command == ROTATION)
                {
                    MoveCommand(command );
                    command = NO_ACTION;
                }
                UpDateCurrCubesPos(&curr_cubes);
                //在game_board_cubes将当前cubes的位置置1
                SetCubes(game_board_cube, 1);
                //绘制当前cubes,并显示出来
                DelayMs(20);
                DrawTericCubes(curr_cubes);
            */    

                full_row_flag = IsFullRows();
                if (full_row_flag)
                {
                    uchar full_row_count = FullRowsNum();
                    UpdateScore(full_row_count);
                    
                    if (game_score >= 3)
                    {
                        game_score = 0;
                    //    game_level ++;
                        real_game_level ++;
                    }
                    ClearFullRows();
                    
                    
                    DrawScore();
                    DrawCubes(game_board_cube);    
                }
                
                //判断游戏是否结束
                game_over_flag = 0;
                game_over_flag = IsGameOver();
                if (game_over_flag == 1)
                {
                    goto label_game_over;
                }
                //重新获得每一个柱子的最大高度
                GetHightCubePerColumn();
                //重新生成cube

                curr_cubes = next_cubes;
        
                next_cube_type = rand_num;
                next_cubes = InitCubes(next_cube_type);
                ShowNextCubes();
                command = NO_ACTION;
            }

            time = 0;
            start_count = 1;

            Timer_Init();        //重新打开定时器
        }
    }

    while(1);


label_stop_game:
    
    while (1)
    {
        KeyDown();
        if (command == CONFIRM)
        {
            command = NO_ACTION;
            Timer_Init();
            goto label_play_game;
        }
    }

label_quit_game:
    
    DelayMs(100);
    command = NO_ACTION;
    while(1)
    {
        KeyDown();
        if (command == CONFIRM)
        {
            command = NO_ACTION;
            goto label_play_game;
        }
        if (command == QUIT)
        {
            RestartInit();
            goto label_start_game;
            
        }
    }

label_game_over:
        
        RestartInit();
        GameMainScreen(command, game_over_flag);
        game_over_flag = 0;
        command = NO_ACTION;
        for(;;)
        {
            KeyDown();
            if (command == CONFIRM)
            {
                RestartInit();
                goto label_start_play_game;
            }
        }
        while(1);
}

//teric.c   程序的逻辑实验部分

 

#include "t6963.c"
#include "variable.h"


/////////////////////////////////////////////////////////////

/**************************************************************************
延时ms:延时的毫秒数
***************************************************************************/
void DelayMs(uint ms)
{
     uint iq0, iq1;
     for (iq0 = ms; iq0 > 0; iq0--)
     for (iq1 = 1000; iq1 > 0; iq1--); 
}


void DrawWall()
{
    uchar y;
    uchar x;
    for (y = 0; y < GAME_BOARD_HEIGHT; y ++)
    {
        for (x = 1; x < 3; x ++)
        {
            LCM_pixel(WALL_LOC+x, y, 1);
        }
    }
}

void DrawWelcomeBoard()
{
    
}
void WriteCube(uchar x, uchar y, bit is_show)
{
    uchar i, j;
    if (is_show)
    {
        
        for (i = x; i < x + PIXEL_PER_CUBE_X; i ++)
        {
            if (i == x + PIXEL_PER_CUBE_X - 1)
            {
                LCM_pixel(i, j, 0);
                continue;
            }
            for (j = y; j < y + PIXEL_PER_CUBE_Y; j ++)
            {
                if (j == y + PIXEL_PER_CUBE_Y - 1)
                {
                    LCM_pixel(i, j, 0);
                }
                else
                {
                    LCM_pixel(i, j, 1);
                }
            }
            
        }
    }
    else
    {
        for (i = x; i < x + PIXEL_PER_CUBE_X; i ++)
        {
            for (j = y; j < y + PIXEL_PER_CUBE_Y; j ++)
            {
                LCM_pixel(i, j, 0);
            }
        }
    }
}

void SetGameBoardCubeBit(uint* game_board_cube, uchar x, uchar y, bit is_set)
{    
    if (is_set == 1)
    {
        uint tmp = game_board_cube[y];
        game_board_cube[y] = tmp | (0x8000 >> x);
    }
    else if (is_set == 0)
    {
        uint tmp1 = game_board_cube[y];
        uint tmp2 = tmp1 & (0x8000 >> x);
        game_board_cube[y] = tmp1 & (~tmp2);
    }
}

bit IsCube(uint* game_board_cube, uchar x, uchar y)
{
    uint tmp1 = game_board_cube[y];

    bit tmp2 = tmp1 & (0x8000 >> x);
    return tmp2;
}

void DrawCube(uint* game_board_cube, uchar x, uchar y)
{
    bit flag = IsCube(game_board_cube, x, y);
    if (flag)
    {
        WriteCube(x * PIXEL_PER_CUBE_X, y * PIXEL_PER_CUBE_Y, 1);
    }
    else
    {
        WriteCube(x * PIXEL_PER_CUBE_X, y * PIXEL_PER_CUBE_Y, 0);
    }
}

void DrawCubes(uint* game_board_cube)
{
    uchar x;
    uchar y;
    for (y = 0; y < CUBE_COUNT_Y; y ++)
    {
        for (x = 0; x < CUBE_COUNT_X; x ++)
        {
            DrawCube(game_board_cube, x, y);
        }
    }
}


//bit IsLeftNoCubes(uint* game_board_cube, uchar x1, uchar y1, uchar x2, uchar y2, uchar x3, uchar y3, uchar x4, uchar y4)
bit IsLeftNoCubes(uint* game_board_cube, Cubes cube)
{
    bit flag = 0;
    bit flag1 = IsCube(game_board_cube, cube.x1-1, cube.y1);
    bit flag2 = IsCube(game_board_cube, cube.x2-1, cube.y2);
    bit flag3 = IsCube(game_board_cube, cube.x3-1, cube.y3);
    bit flag4 = IsCube(game_board_cube, cube.x4-1, cube.y4);
    if (flag1 == 0 && flag2 == 0 && flag3 == 0 && flag4 == 0)
    {
        flag = 1;
    }
    return flag;
}
//bit IsRightNoCubes(uint* game_board_cube, uchar x1, uchar y1, uchar x2, uchar y2, uchar x3, uchar y3, uchar x4, uchar y4)
bit IsRightNoCubes(uint* game_board_cube, Cubes cube)
{
    bit flag = 0;
    bit flag1 = IsCube(game_board_cube, cube.x1+1, cube.y1);
    bit flag2 = IsCube(game_board_cube, cube.x2+1, cube.y2);
    bit flag3 = IsCube(game_board_cube, cube.x3+1, cube.y3);
    bit flag4 = IsCube(game_board_cube, cube.x4+1, cube.y4);
    if (flag1 == 0 && flag2 == 0 && flag3 == 0 && flag4 == 0)
    {
        flag = 1;
    }
    return flag;
}

void UpDateCurrCubesPos(Cubes* cubes)
{
//    Cubes curr_cubes = (*cubes);
    if ((*cubes).cube_type == 0)        
    {
        // - - - -

        (*cubes).x2 = (*cubes).x1+1;
        (*cubes).y2 = (*cubes).y1;
        (*cubes).x3 = (*cubes).x1+2;
        (*cubes).y3 = (*cubes).y1;
        (*cubes).x4 = (*cubes).x1+3;
        (*cubes).y4 = (*cubes).y1;
    }
    else if ((*cubes).cube_type == 1)//
    {
        // |
        // |
        // |
        // |

        (*cubes).x2 = (*cubes).x1;
        (*cubes).y2 = (*cubes).y1+1;
        (*cubes).x3 = (*cubes).x1;
        (*cubes).y3 = (*cubes).y1+2;
        (*cubes).x4 = (*cubes).x1;
        (*cubes).y4 = (*cubes).y1+3;
    }
    else if ((*cubes).cube_type == 2)
    {
        // - -
        // - -
        (*cubes).x2 = (*cubes).x1 + 1;
        (*cubes).y2 = (*cubes).y1;
        (*cubes).x3 = (*cubes).x1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 + 1;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }

    else if ((*cubes).cube_type == 3)
    {
        // |
        // - -
        //    |
        (*cubes).x2 = (*cubes).x1;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 + 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 + 1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }
    else if ((*cubes).cube_type == 4)
    {
        //     __
        //     |
        //__|   
        (*cubes).x2 = (*cubes).x1 - 1;
        (*cubes).y2 = (*cubes).y1;
        (*cubes).x3 = (*cubes).x1 - 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 - 2;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }

    else if ((*cubes).cube_type == 5)
    {
        //      |
        // - -    
        // |  
        (*cubes).x2 = (*cubes).x1;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 - 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 - 1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }
    else if ((*cubes).cube_type == 6)
    {
        //     __
        //       |    
        //    |__
        (*cubes).x2 = (*cubes).x1 + 1;
        (*cubes).y2 = (*cubes).y1 ;
        (*cubes).x3 = (*cubes).x1 + 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 + 2;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }
    else if ((*cubes).cube_type == 7)
    {
        //     |
        //     |
        //__|   
        (*cubes).x2 = (*cubes).x1;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1;
        (*cubes).y3 = (*cubes).y1 + 2;
        (*cubes).x4 = (*cubes).x1 - 1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }

    else if ((*cubes).cube_type == 8)
    {
        //     
        // |
        // |- -  
        (*cubes).x2 = (*cubes).x1;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 + 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 + 2;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }
    else if ((*cubes).cube_type == 9)
    {
        //     |-
        //     |
        //  |   
        (*cubes).x2 = (*cubes).x1 - 1;
        (*cubes).y2 = (*cubes).y1;
        (*cubes).x3 = (*cubes).x1 - 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 - 1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }
    
    else if ((*cubes).cube_type == 10)
    {
        // 
        //- - -
        //       |   
        (*cubes).x2 = (*cubes).x1 + 1;
        (*cubes).y2 = (*cubes).y1 ;
        (*cubes).x3 = (*cubes).x1 + 2;
        (*cubes).y3 = (*cubes).y1 ;
        (*cubes).x4 = (*cubes).x1 + 2;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }

    else if (curr_cubes.cube_type == 11)
    {
        // |
        // |
        // - -   
        (*cubes).x2 = (*cubes).x1 ;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 ;
        (*cubes).y3 = (*cubes).y1 + 2;
        (*cubes).x4 = (*cubes).x1 + 1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }

    else if (curr_cubes.cube_type == 12)
    {
        // - - -
        // |
        //  
        (*cubes).x2 = (*cubes).x1 + 1;
        (*cubes).y2 = (*cubes).y1;
        (*cubes).x3 = (*cubes).x1 + 2;
        (*cubes).y3 = (*cubes).y1 ;
        (*cubes).x4 = (*cubes).x1 ;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }

    else if ((*cubes).cube_type == 13)
    {
        // -|
        //  |
        //  |   
        (*cubes).x2 = (*cubes).x1 + 1;
        (*cubes).y2 = (*cubes).y1;
        (*cubes).x3 = (*cubes).x1 + 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 + 1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }
    else if ((*cubes).cube_type == 14)
    {
        // 
        //     |
        // - - -   
        (*cubes).x2 = (*cubes).x1 - 2;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 - 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 ;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }

    else if ((*cubes).cube_type == 15)
    {
        //   |
        // - - -   
        (*cubes).x2 = (*cubes).x1 - 1;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 ;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 + 1;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }

    else if ((*cubes).cube_type == 16)
    {
        //   |
        //   |- 
        //   |
        (*cubes).x2 = (*cubes).x1 ;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 + 1;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }

    else if ((*cubes).cube_type == 17)
    {
        //  - - -
        //    | 
        //   
        (*cubes).x2 = (*cubes).x1 + 1;
        (*cubes).y2 = (*cubes).y1 ;
        (*cubes).x3 = (*cubes).x1 + 2;
        (*cubes).y3 = (*cubes).y1 ;
        (*cubes).x4 = (*cubes).x1 + 1;
        (*cubes).y4 = (*cubes).y1 + 1;    
    }
    else if ((*cubes).cube_type == 18)
    {
        //   |
        //  _| 
        //   |
        (*cubes).x2 = (*cubes).x1 - 1;
        (*cubes).y2 = (*cubes).y1 + 1;
        (*cubes).x3 = (*cubes).x1 ;
        (*cubes).y3 = (*cubes).y1 + 1;
        (*cubes).x4 = (*cubes).x1 ;
        (*cubes).y4 = (*cubes).y1 + 2;    
    }


}
Cubes InitCubes(uchar cube_type)
{
    Cubes cubes = {0};
    if (cube_type == 0)        // 。。。。
    {
        // - - - -
        cubes.x1 = CUBE_COUNT_X/2 - 2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;
        
        cubes.cube_type = cube_type;
        cubes.signature = 0;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 1)        
    {
    
// |
// |
// |
// |

        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 0;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 2)    
    {
        // - -
        // - -
        cubes.x1 = CUBE_COUNT_X/2 - 1;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 1;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 3)    
    {
        // |
        // - -
        //    |
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 2;
        UpDateCurrCubesPos(&cubes);
    }

    else if (cube_type == 4)        // 。。。。
    {
        //   __
        //  |
        //__|
        cubes.x1 = CUBE_COUNT_X/2 - 2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 2;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 5)        
    {    
        //      |
        // - -    
        // | 
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 3;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 6)    
    {
        //     __
        //       |    
        //    |__
        cubes.x1 = CUBE_COUNT_X/2 - 1;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 3;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 7)    
    {
        //     |
        //     |
        //__| 
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 4;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 8)        // 。。。。
    {
        //     
        // |
        // |- -  
        cubes.x1 = CUBE_COUNT_X/2 - 2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 4;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 9)        
    {
        //     |-
        //     |
        //  |
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
         cubes.signature = 4;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 10)    
    {
        // 
        //- - -
        //       |  
        cubes.x1 = CUBE_COUNT_X/2 - 1;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 4;
        UpDateCurrCubesPos(&cubes);
    }

    else if (cube_type == 11)        // 。。。。
    {
        
        // |
        // |
        // - - 
        
        cubes.x1 = CUBE_COUNT_X/2 - 2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 5;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 12)        
    {
        // - - -
        // |

        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 5;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 13)    
    {
        // -|
        //  |
        //  |  
        cubes.x1 = CUBE_COUNT_X/2 - 1;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 5;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 14)    
    {
    //     |
    // - - - 
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 5;
        UpDateCurrCubesPos(&cubes);
    }
    
    else if (cube_type == 15)    
    {
        //    |
        // - - - 
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 6;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 16)    
    {
        //   |
        //   |- 
        //   |
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 6;
        UpDateCurrCubesPos(&curr_cubes);
    }
    else if (cube_type == 17)    
    {
        //  - - -
        //    | 
 
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 6;
        UpDateCurrCubesPos(&cubes);
    }
    else if (cube_type == 18)    
    {
        //   |
        //  _| 
        //   |
        cubes.x1 = CUBE_COUNT_X/2;        //GAME_BOARD_WIDTH/2 - 1;
        cubes.y1 = 0;

        cubes.cube_type = cube_type;
        cubes.signature = 6;
        UpDateCurrCubesPos(&cubes);
    }

    return cubes;
}

void SetCubes(uint* game_board_cube, bit is_set)
{
    SetGameBoardCubeBit(game_board_cube, curr_cubes.x1, curr_cubes.y1, is_set);
    SetGameBoardCubeBit(game_board_cube, curr_cubes.x2, curr_cubes.y2, is_set);
    SetGameBoardCubeBit(game_board_cube, curr_cubes.x3, curr_cubes.y3, is_set);
    SetGameBoardCubeBit(game_board_cube, curr_cubes.x4, curr_cubes.y4, is_set);
}

void DrawTericCubes(Cubes cubes)
{
    DrawCube(game_board_cube, cubes.x1,  cubes.y1);
    DrawCube(game_board_cube, cubes.x2,  cubes.y2);
    DrawCube(game_board_cube, cubes.x3,  cubes.y3);
    DrawCube(game_board_cube, cubes.x4,  cubes.y4);
}

void GetHightCubePerColumn()
{
    uchar x, y;
//    uchar tmp1;
    bit flag;
    
    for (x = 0; x < CUBE_COUNT_X; x ++)
    {
        for (y = 0; y < CUBE_COUNT_Y; y++)
        {
            flag = IsCube(game_board_cube, x, y);
            if (flag == 1)
            {
                highest_cube_per_column[x] = y - 1;
                if (highest_cube_per_column[x] == 0)
                    highest_cube_per_column[x] = 0;
                    
                break;
            }
            else if (flag == 0)
            {
                if (y == CUBE_COUNT_Y - 1)
                    highest_cube_per_column[x] = y;
            }
        }
    //    highest_cube_per_column[x]
    }
}

bit IsWall(uchar x, uchar y)
{
    bit flag = 0;
    if (x <0 || x >= CUBE_COUNT_X || y < 0 || y >= CUBE_COUNT_Y)
    {
        flag = 1;
        return flag;
    }
        
    return flag;
}

void RotationCubes(uchar x1, uchar y1, uchar x2, uchar y2, uchar x3, uchar y3, uchar x4, uchar y4, uchar cube_type)
{
    bit flag1, flag2, flag3, flag4;

    flag1 = IsWall(x1, y1);
    flag2 = IsWall(x2, y2);
    flag3 = IsWall(x3, y3);
    flag4 = IsWall(x4, y4);

    if (flag1 == 1 || flag2 == 1 || flag3 == 1 || flag4 == 1)
        return;

    flag1 = IsCube(game_board_cube, x1, y1);
    flag2 = IsCube(game_board_cube, x2, y2);
    flag3 = IsCube(game_board_cube, x3, y3);
    flag4 = IsCube(game_board_cube,x4, y4);

    if (flag1 == 0 && flag2 == 0 && flag3 == 0 && flag4 == 0)
    {
        curr_cubes.cube_type = cube_type;
        curr_cubes.x1 = x1;
        curr_cubes.y1 = y1;
        UpDateCurrCubesPos(&curr_cubes);
    }
}

void RotationAction(uchar signature)
{
    uchar x1, y1, x2, y2, x3, y3, x4, y4;

    if (curr_cubes.signature == 0)
    {
        if (curr_cubes.cube_type == 0)
        {

            x1 = curr_cubes.x1;
            y1 = curr_cubes.y1 - 3;

            x2 = x1;
            y2 = y1+1;
            x3 = x1;
            y3 = y1+2;
            x4 = x1;
            y4 = y1+3;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 1);
            
        }
        else if (curr_cubes.cube_type == 1)
        {
            
            
            x1 = curr_cubes.x4;
            y1 = curr_cubes.y4;

            x2 = x1+1;
            y2 = y1;
            x3 = x1+2;
            y3 = y1;
            x4 = x1+3;
            y4 = y1;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 0);

        }    
    }
    else if (signature == 1)
    {
        //do nothing 
    }
    else if (signature == 2)
    {
        if (curr_cubes.cube_type == 3)
        {

            x1 = curr_cubes.x1 + 2;
            y1 = curr_cubes.y1 + 1;

            x2 = x1 - 1;
            y2 = y1;
            x3 = x1 - 1;
            y3 = y1 + 1;
            x4 = x1 - 2;
            y4 = y1 + 1;    
            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 4);
            
        }
        else if (curr_cubes.cube_type == 4)
        {
            
            
            x1 = curr_cubes.x1 - 2;
            y1 = curr_cubes.y1 - 1;

            x2 = x1;
            y2 = y1 + 1;
            x3 = x1 + 1;
            y3 = y1 + 1;
            x4 = x1 + 1;
            y4 = y1 + 2;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 3);

        }

    }
    else if (signature == 3)
    {
        if (curr_cubes.cube_type == 5)
        {
            //      |
            // - -    
            // |  
            x1 = curr_cubes.x3;
            y1 = curr_cubes.y3;

            x2 = x1 + 1;
            y2 = y1 ;
            x3 = x1 + 1;
            y3 = y1 + 1;
            x4 = x1 + 2;
            y4 = y1 + 1;
            
            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 6);
        }
        else if (curr_cubes.cube_type == 6)
        {
            //     __
            //       |    
            //    |__
            x1 = curr_cubes.x3;
            y1 = curr_cubes.y3;

            x2 = x1;
            y2 = y1 + 1;
            x3 = x1 - 1;
            y3 = y1 + 1;
            x4 = x1 - 1;
            y4 = y1 + 2;
            
            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 5);
        }
    }
    else if (signature == 4)
    {
        if (curr_cubes.cube_type == 7)
        {
            //     |
            //     |
            //__|   
            x1 = curr_cubes.x4;
            y1 = curr_cubes.y4 - 1;


            x2 = x1;
            y2 = y1 + 1;
            x3 = x1 + 1;
            y3 = y1 + 1;
            x4 = x1 + 2;
            y4 = y1 + 1;
            
            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 8);

        }
    
        else if (curr_cubes.cube_type == 8)
        {
            //     
            // |
            // |- -  

            x1 = curr_cubes.x1 + 1;
            y1 = curr_cubes.y1 - 1;


            x2 = x1 - 1;
            y2 = y1;
            x3 = x1 - 1;
            y3 = y1 + 1;
            x4 = x1 - 1;
            y4 = y1 + 2;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 9);

        }
        else if (curr_cubes.cube_type == 9)
        {
            //     |-
            //     |
            //  |   

            x1 = curr_cubes.x3;
            y1 = curr_cubes.y3;


            x2 = x1 + 1;
            y2 = y1 ;
            x3 = x1 + 2;
            y3 = y1 ;
            x4 = x1 + 2;
            y4 = y1 + 1;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 10);

        }
        
        else if (curr_cubes.cube_type == 10)
        {
            // 
            //- - -
            //       |   
            x1 = curr_cubes.x2;
            y1 = curr_cubes.y2 - 1;


            x2 = x1;
            y2 = y1 + 1;
            x3 = x1;
            y3 = y1 + 2;
            x4 = x1 - 1;
            y4 = y1 + 2;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 7);

        }
    }
    else if (signature == 5)
    {
        if (curr_cubes.cube_type == 11)
        {
            // |
            // |
            // - -   
            x1 = curr_cubes.x2;
            y1 = curr_cubes.y2;

            x2 = x1 + 1;
            y2 = y1;
            x3 = x1 + 2;
            y3 = y1 ;
            x4 = x1 ;
            y4 = y1 + 1;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 13);
        }


    
        else if (curr_cubes.cube_type == 12)
        {
            // - - -
            // |
            //  

            x1 = curr_cubes.x1;
            y1 = curr_cubes.y1 - 1;
            
            x2 = x1 + 1;
            y2 = y1;
            x3 = x1 + 1;
            y3 = y1 + 1;
            x4 = x1 + 1;
            y4 = y1 + 2;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 13);
        }
    
        else if (curr_cubes.cube_type == 13)
        {
            // -|
            //  |
            //  |   

            x1 = curr_cubes.x3 + 1;
            y1 = curr_cubes.y3;


            x2 = x1 - 2;
            y2 = y1 + 1;
            x3 = x1 - 1;
            y3 = y1 + 1;
            x4 = x1 ;
            y4 = y1 + 1;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 14);

        }
        else if (curr_cubes.cube_type == 14)
        {
            // 
            //     |
            // - - -   

            x1 = curr_cubes.x2;
            y1 = curr_cubes.y2 - 2;


            x2 = x1 - 2;
            y2 = y1 + 1;
            x3 = x1 - 1;
            y3 = y1 + 1;
            x4 = x1 ;
            y4 = y1 + 1;
            

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 11);

        }
    }
    else if (signature == 6)
    {

        if (curr_cubes.cube_type == 15)
        {
            //   |
            // - - -   
        
            x1 = curr_cubes.x1 - 1;
            y1 = curr_cubes.y1 - 1;

            x2 = x1 ;
            y2 = y1 + 1;
            x3 = x1 + 1;
            y3 = y1 + 1;
            x4 = x1;
            y4 = y1 + 2;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 16);
        }
    
        else if (curr_cubes.cube_type == 16)
        {
            //   |
            //   |- 
            //   |
    
            x1 = curr_cubes.x2;
            y1 = curr_cubes.y2;

            x2 = x1 + 1;
            y2 = y1 ;
            x3 = x1 + 2;
            y3 = y1 ;
            x4 = x1 + 1;
            y4 = y1 + 1;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 17);
        }
    
        else if (curr_cubes.cube_type == 17)
        {
            //  - - -
            //    | 
            //   
            x1 = curr_cubes.x2;
            y1 = curr_cubes.y2 - 1;

            x2 = x1 - 1;
            y2 = y1 + 1;
            x3 = x1 ;
            y3 = y1 + 1;
            x4 = x1 ;
            y4 = y1 + 2;

            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 18);
        }
        else if (curr_cubes.cube_type == 18)
        {
            //   |
            //  _| 
            //   |

            x1 = curr_cubes.x3;
            y1 = curr_cubes.y3;

            x2 = x1 - 1;
            y2 = y1 + 1;
            x3 = x1 ;
            y3 = y1 + 1;
            x4 = x1 + 1;
            y4 = y1 + 1;


            RotationCubes(x1, y1, x2, y2, x3, y3, x4, y4, 15);
        }
    }
}

void MoveCommand(uchar command)
{
    if (command == MOVE_LEFT)
    {
        if (curr_cubes.x1 > 0 && curr_cubes.x2 > 0 && curr_cubes.x3 > 0 && curr_cubes.x4 > 0)
        {
    
            bit flag = IsLeftNoCubes(game_board_cube, curr_cubes);
            if (flag == 1)
            {
                curr_cubes.x1 --;
            }
        }
    }
    else if (command == MOVE_RIGHT)
    {
        if (curr_cubes.x1 < CUBE_COUNT_X-1 && curr_cubes.x2 < CUBE_COUNT_X-1 &&
            curr_cubes.x3 < CUBE_COUNT_X-1 && curr_cubes.x4 < CUBE_COUNT_X-1) 
        {

            bit flag = IsRightNoCubes(game_board_cube, curr_cubes);
            if (flag == 1)
            {
                curr_cubes.x1 ++;
            }
        }

    }
    else if (command == MOVE_DOWN)        
    {
        uchar i;
        for (i = 0; i < 3; i ++)
        {
            if(curr_cubes.y1 < highest_cube_per_column[curr_cubes.x1]-1 &&
               curr_cubes.y2 < highest_cube_per_column[curr_cubes.x2]-1 &&
               curr_cubes.y3 < highest_cube_per_column[curr_cubes.x3]-1 &&
               curr_cubes.y4 < highest_cube_per_column[curr_cubes.x4]-1)
            {
                curr_cubes.y1 ++;
                UpDateCurrCubesPos(&curr_cubes);    
            }
        }
    }
    else if (command == ROTATION)
    {
        
        RotationAction(curr_cubes.signature);    
    }
    else if (command == NO_ACTION)
    {
        //do nothing
    }

    command = 0x04;
}

void ClearFullRow(uchar y)
{
    char yy;


    for (yy = (char)y; yy > 0; yy--)
    {
        game_board_cube[yy] = game_board_cube[yy-1];
    }

    game_board_cube[0] = 0;    

}
void ClearFullRows()
{
    uchar x, y;
    uchar tmp = 0;
    bit flag;
    for (y = 0; y < CUBE_COUNT_Y; y ++)
    {
        tmp = 0;
        for (x = 0; x < CUBE_COUNT_X; x ++)
        {
            flag = IsCube(game_board_cube, x, y);
            if (flag == 1)
            {
                tmp ++;
            }
        }

        if (tmp == CUBE_COUNT_X)
        {
            //clear that row and update the full screen
            ClearFullRow(y);
        }
        
    }
}


bit IsFullRow(uchar y)
{

    uchar x;
    bit flag;

    for (x = 0; x < CUBE_COUNT_X; x ++)
    {
        flag = IsCube(game_board_cube, x, y);
        if (flag == 0)
        {
            return flag;
        }
            
    }
    return flag;
}

bit IsFullRows()
{
    uchar y;
    bit flag;
    for (y = 0; y < CUBE_COUNT_Y; y++)
    {
        flag = IsFullRow(y);
        if (flag == 1)
            return flag;
    }
    return flag;
}

uchar FullRowsNum()
{
    uchar y = 0;
    bit flag = 0;
    uchar full_row_count = 0;
    for (y = 0; y < CUBE_COUNT_Y ; y ++)
    {
        flag = IsFullRow(y);
        if (flag == 1)
        {
            full_row_count ++;
        }
    }

    return full_row_count;
}

void UpdateScore(uchar full_row_count)
{
    if (full_row_count == 1)
    {
        game_score++;
    }
    else if (full_row_count == 2)
    {
        game_score = game_score + 4;
    }
    else if (full_row_count == 3)
    {
        game_score = game_score + 7;
    }
    else if (full_row_count == 4)
    {
        game_score = game_score + 10;
    }
    else
    {
        //do nothing 
        //if the program is right ,this case won‘t be appeared 
    }
}
/*
void DrawNumNone(uchar x, uchar y)
{
    LCM_pixel(x + 0, y + 0, 0);
    LCM_pixel(x + 0, y + 1, 0);
    LCM_pixel(x + 0, y + 2, 0);
    LCM_pixel(x + 0, y + 3, 0);
    LCM_pixel(x + 0, y + 4, 0);
    LCM_pixel(x + 0, y + 5, 0);

    LCM_pixel(x + 1, y + 0, 0);
    LCM_pixel(x + 1, y + 1, 0);
    LCM_pixel(x + 1, y + 2, 0);
    LCM_pixel(x + 1, y + 3, 0);
    LCM_pixel(x + 1, y + 4, 0);
    LCM_pixel(x + 1, y + 5, 0);

    LCM_pixel(x + 2, y + 0, 0);
    LCM_pixel(x + 2, y + 1, 0);
    LCM_pixel(x + 2, y + 2, 0);
    LCM_pixel(x + 2, y + 3, 0);
    LCM_pixel(x + 2, y + 4, 0);
    LCM_pixel(x + 2, y + 5, 0);

    LCM_pixel(x + 3, y + 0, 0);
    LCM_pixel(x + 3, y + 1, 0);
    LCM_pixel(x + 3, y + 2, 0);
    LCM_pixel(x + 3, y + 3, 0);
    LCM_pixel(x + 3, y + 4, 0);
    LCM_pixel(x + 3, y + 5, 0);
}
void DrawNumOne(uchar x, uchar y)
{
    LCM_pixel(x + 3, y + 0, 1);
    LCM_pixel(x + 3, y + 1, 1);
    LCM_pixel(x + 3, y + 2, 1);
    LCM_pixel(x + 3, y + 3, 1);
    LCM_pixel(x + 3, y + 4, 1);
    LCM_pixel(x + 3, y + 5, 1);
}
void DrawNumTwo(uchar x, uchar y)
{
    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 1, y, 1);
    LCM_pixel(x + 2, y, 1);
    LCM_pixel(x + 3, y, 1);
    LCM_pixel(x + 3, y + 1, 1);
    LCM_pixel(x + 3, y + 2, 1);
    LCM_pixel(x + 2, y + 2, 1);
    LCM_pixel(x + 1, y + 2, 1);
    LCM_pixel(x + 0, y + 2, 1);
    LCM_pixel(x + 0, y + 3, 1);
    LCM_pixel(x + 0, y + 4, 1);
    LCM_pixel(x + 0, y + 5, 1);
    LCM_pixel(x + 1, y + 5, 1);
    LCM_pixel(x + 2, y + 5, 1);
    LCM_pixel(x + 3, y + 5, 1);
}
void DrawNumThree(uchar x, uchar y)
{

    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 1, y, 1);
    LCM_pixel(x + 2, y, 1);
    LCM_pixel(x + 3, y, 1);
    LCM_pixel(x + 3, y + 1, 1);
    LCM_pixel(x + 3, y + 2, 1);
    LCM_pixel(x + 2, y + 2, 1);
    LCM_pixel(x + 1, y + 2, 1);
    LCM_pixel(x + 0, y + 2, 1);
    LCM_pixel(x + 3, y + 3, 1);
    LCM_pixel(x + 3, y + 4, 1);
    LCM_pixel(x + 3, y + 5, 1);
    LCM_pixel(x + 3, y + 5, 1);
    LCM_pixel(x + 2, y + 5, 1);
    LCM_pixel(x + 1, y + 5, 1);
}

void DrawNumFour(uchar x, uchar y)
{
    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 3, y, 1);
    LCM_pixel(x + 0, y + 1, 1);
    LCM_pixel(x + 3, y + 1, 1);
    LCM_pixel(x + 0, y + 2, 1);
    LCM_pixel(x + 1, y + 2, 1);
    LCM_pixel(x + 2, y + 2, 1);
    LCM_pixel(x + 3, y + 2, 1);
    LCM_pixel(x + 3, y + 3, 1);
    LCM_pixel(x + 3, y + 4, 1);
    LCM_pixel(x + 3, y + 5, 1);
}
void DrawNumFive(uchar x, uchar y)
{
    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 1, y, 1);
    LCM_pixel(x + 2, y, 1);
    LCM_pixel(x + 3, y, 1);

    LCM_pixel(x + 0, y+1, 1);

    LCM_pixel(x + 0, y+2, 1);
    LCM_pixel(x + 1, y+2, 1);
    LCM_pixel(x + 2, y+2, 1);
    LCM_pixel(x + 3, y+2, 1);

    LCM_pixel(x + 3, y+3, 1);
//    LCM_pixel1(x + 3, y+3, 1);

    LCM_pixel(x + 3, y+4, 1);
//    LCM_pixel1(x + 3, y+4, 1);

    LCM_pixel(x + 0, y+5, 1);
    LCM_pixel(x + 1, y+5, 1);
    LCM_pixel(x + 2, y+5, 1);
    LCM_pixel(x + 3, y+5, 1);
}

void DrawNumSix(uchar x, uchar y)
{
    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 1, y, 1);
    LCM_pixel(x + 2, y, 1);
    LCM_pixel(x + 3, y, 1);

    LCM_pixel(x + 0, y+1, 1);

    LCM_pixel(x + 0, y+2, 1);
    LCM_pixel(x + 1, y+2, 1);
    LCM_pixel(x + 2, y+2, 1);
    LCM_pixel(x + 3, y+2, 1);

    LCM_pixel(x + 3, y+3, 1);

    LCM_pixel(x + 3, y+4, 1);
    LCM_pixel(x + 0, y+5, 1);
    LCM_pixel(x + 1, y+5, 1);
    LCM_pixel(x + 2, y+5, 1);
    LCM_pixel(x + 3, y+5, 1);

    LCM_pixel(x + 0, y+3, 1);
    LCM_pixel(x + 0, y+4, 1);
}

void DrawNumSeven(uchar x, uchar y)
{
    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 1, y, 1);
    LCM_pixel(x + 2, y, 1);
    LCM_pixel(x + 3, y, 1);
    LCM_pixel(x + 3, y+1, 1);
    LCM_pixel(x + 3, y+2, 1);
    LCM_pixel(x + 3, y+3, 1);
    LCM_pixel(x + 3, y+4, 1);
    LCM_pixel(x + 3, y+5, 1);
}
void DrawNumEight(uchar x, uchar y)
{
    LCM_pixel(x + 0, y, 1);
    LCM_pixel(x + 1, y, 1);
    LCM_pixel(x + 2, y, 1);
    LCM_pixel(x + 3, y, 1);
    LCM_pixel(x + 3, y+1, 1);
    LCM_pixel(x + 3, y+2, 1);
    LCM_pixel(x + 3, y+3, 1);
    LCM_pixel(x + 3, y+4, 1);
    LCM_pixel(x + 3, y+5, 1);

    LCM_pixel(x + 0, y + 1, 1);
    LCM_pixel(x + 0, y + 2, 1);
    LCM_pixel(x + 1, y + 2, 1);
    LCM_pixel(x + 2, y + 2, 1);
    LCM_pixel(x + 0, y + 3, 1);
    LCM_pixel(x + 0, y + 4, 1);
    LCM_pixel(x + 0, y + 5, 1);
    LCM_pixel(x + 1, y + 5, 1);
    LCM_pixel(x + 2, y + 5, 1);
}
void DrawNumNine(uchar x, uchar y)
{
    LCM_pixel(x, y, 1);
    LCM_pixel(x+1, y, 1);
    LCM_pixel(x+2, y, 1);
    LCM_pixel(x+3, y, 1);
    
    LCM_pixel(x, y+1, 1);
    LCM_pixel(x+3, y+1, 1);

    LCM_pixel(x, y+2, 1);
    LCM_pixel(x+1, y+2, 1);
    LCM_pixel(x+2, y+2, 1);
    LCM_pixel(x+3, y+2, 1);

    LCM_pixel(x+3, y+3, 1);
    LCM_pixel(x+3, y+4, 1);
    LCM_pixel(x+3, y+5, 1);

}
void DrawNumZero(uchar x, uchar y)
{
    LCM_pixel(x, y, 1);
    LCM_pixel(x+1, y, 1);
    LCM_pixel(x+2, y, 1);
    LCM_pixel(x+3, y, 1);

    LCM_pixel(x, y+1, 1);
    LCM_pixel(x+3, y+1, 1);

    LCM_pixel(x, y+2, 1);
    LCM_pixel(x+3, y+2, 1);

    LCM_pixel(x, y+3, 1);
    LCM_pixel(x+3, y+3, 1);

    LCM_pixel(x, y+4, 1);
    LCM_pixel(x+3, y+4, 1);

    LCM_pixel(x, y+5, 1);
    LCM_pixel(x+1, y+5, 1);
    LCM_pixel(x+2, y+5, 1);
    LCM_pixel(x+3, y+5, 1);
}

void DrawNums(uchar x, uchar y, uchar number)
{
    DrawNumNone(x, y);
    if (number == 1)
    {
        DrawNumOne(x, y);
    }
    else if (number == 2)
    {
        DrawNumTwo(x, y);
    }
    else if (number == 3)
    {
        DrawNumThree(x, y);
    }
    else if (number == 4)
    {
        DrawNumFour(x, y);
    }
    else if (number == 5)
    {
        DrawNumFive(x, y);
    }
    else if (number == 6)
    {
        DrawNumSix(x, y);
    }
    else if (number == 7)
    {
    //    DrawNumNone(x, y);
        DrawNumSeven(x, y);
    }
    else if (number == 8)
    {
        DrawNumEight(x, y);
    }
    else if (number == 9)
    {
        DrawNumNine(x, y);
    }
    else if (number == 0)
    {
        
        DrawNumZero(x, y);
    }
}
*/
void DrawScore()
{
    //显示分数数字
//    game_score1 = (uchar)(game_score / 100);
//    game_score2 = (uchar)(game_score /10 % 10);
//    game_score3 = (uchar)(game_score % 10);
//    game_score4 = (uchar)(game_score % 1000);
    
//    DrawNums(SCORE_NUM_POS_X,                 SCORE_NUM_POS_Y, game_score1);
//    DrawNums(SCORE_NUM_POS_X +  NUM_WIDTH + 1 ,    SCORE_NUM_POS_Y, game_score2);
//    DrawNums(SCORE_NUM_POS_X + 2*(NUM_WIDTH + 1),  SCORE_NUM_POS_Y, game_score3);
//    DrawNums(SCORE_NUM_POS_X + 3*(NUM_WIDTH + 1),     SCORE_NUM_POS_Y, game_score4);

//    game_score = 129;
    LCM_print_ram(7, 0, "level");
    if (real_game_level == 1)
    {
        LCM_print_ram(7, 1, "1");
    }else if(real_game_level == 2)
    {
        LCM_print_ram(7, 1, "2");
    }else if(real_game_level == 3)
    {
        LCM_print_ram(7, 1, "3");
    }else if(real_game_level == 4)
    {
        LCM_print_ram(7, 1, "4");
    }else if(real_game_level == 5)
    {
        LCM_print_ram(7, 1, "5");
    }
    LCM_print_ram(7, 2, "Score");
    game_score_str[0] = (uchar)(game_score / 100) + 0x30;
    game_score_str[1] = (uchar)(game_score /10 % 10) + 0x30;
    game_score_str[2] = (uchar)(game_score % 10) + 0x30;

    LCM_print_ram(7, 3, game_score_str);
}


void ShowNextCubes()
{
    uchar cube_type = next_cubes.cube_type;
    uchar x1, x2, x3, x4, y1, y2, y3, y4;

    WriteCube( NEXT_CUBES_SHOW_POS_X    * PIXEL_PER_CUBE_X,     NEXT_CUBES_SHOW_POS_Y * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+1) * PIXEL_PER_CUBE_X,     NEXT_CUBES_SHOW_POS_Y * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+2) * PIXEL_PER_CUBE_X,     NEXT_CUBES_SHOW_POS_Y * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+3) * PIXEL_PER_CUBE_X,     NEXT_CUBES_SHOW_POS_Y * PIXEL_PER_CUBE_Y, 0);

    WriteCube( NEXT_CUBES_SHOW_POS_X    * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+1) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+1) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+1) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+2) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+1) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+3) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+1) * PIXEL_PER_CUBE_Y, 0);

    WriteCube( NEXT_CUBES_SHOW_POS_X    * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+2) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+1) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+2) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+2) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+2) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+3) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+2) * PIXEL_PER_CUBE_Y, 0);

    WriteCube( NEXT_CUBES_SHOW_POS_X    * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+3) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+1) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+3) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+2) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+3) * PIXEL_PER_CUBE_Y, 0);
    WriteCube((NEXT_CUBES_SHOW_POS_X+3) * PIXEL_PER_CUBE_X,     (NEXT_CUBES_SHOW_POS_Y+3) * PIXEL_PER_CUBE_Y, 0);


    if (cube_type == 4 || cube_type == 5 || cube_type == 7 )
    {
        //x4_min
        x4 = next_cubes.x4;

        x1 = NEXT_CUBES_SHOW_POS_X - x4 + next_cubes.x1;
        x2 = NEXT_CUBES_SHOW_POS_X - x4 + next_cubes.x2;
        x3 = NEXT_CUBES_SHOW_POS_X - x4 + next_cubes.x3;
        
        x4 = NEXT_CUBES_SHOW_POS_X; 

    }
    else if (cube_type == 9 || cube_type == 15 || cube_type == 18 || cube_type == 14)
    {
        //x2_min
        x2 = next_cubes.x2;

        x1 = NEXT_CUBES_SHOW_POS_X - x2 + next_cubes.x1;
        x3 = NEXT_CUBES_SHOW_POS_X - x2 + next_cubes.x3;
        x4 = NEXT_CUBES_SHOW_POS_X - x2 + next_cubes.x4;
        
        x2 = NEXT_CUBES_SHOW_POS_X;
    }
    else 
    {
        //x1_min
        x1 = next_cubes.x1;

        x2 = NEXT_CUBES_SHOW_POS_X - x1 + next_cubes.x2;
        x3 = NEXT_CUBES_SHOW_POS_X - x1 + next_cubes.x3;
        x4 = NEXT_CUBES_SHOW_POS_X - x1 + next_cubes.x4;

        x1 = NEXT_CUBES_SHOW_POS_X;
    }

    y1 = next_cubes.y1;

    y2 = NEXT_CUBES_SHOW_POS_Y - y1 + next_cubes.y2;
    y3 = NEXT_CUBES_SHOW_POS_Y - y1 + next_cubes.y3;
    y4 = NEXT_CUBES_SHOW_POS_Y - y1 + next_cubes.y4;
    y1 = NEXT_CUBES_SHOW_POS_Y;

    WriteCube(x1 * PIXEL_PER_CUBE_X, y1 * PIXEL_PER_CUBE_Y, 1);
    WriteCube(x2 * PIXEL_PER_CUBE_X, y2 * PIXEL_PER_CUBE_Y, 1);
    WriteCube(x3 * PIXEL_PER_CUBE_X, y3 * PIXEL_PER_CUBE_Y, 1);
    WriteCube(x4 * PIXEL_PER_CUBE_X, y4 * PIXEL_PER_CUBE_Y, 1);
    
}
bit IsGameOver()
{
    uchar x;
    bit flag = 0;
    for (x = 0; x < CUBE_COUNT_X; x ++)
    {
        if (highest_cube_per_column[x] == 0)
        {
            flag = 1;
            return flag;
        }         
    }
    return flag;
}

void DrawRect(uchar x1, uchar y1, uchar x2, uchar y2)
{
    uchar x, y;
    for (x = x1; x < x2; x ++)
    {
        LCM_pixel(x, y1, 1);
        LCM_pixel(x, y2, 1);
    }
    for (y = y1; y < y2; y ++)
    {
        LCM_pixel(x1, y, 1);
        LCM_pixel(x2, y, 1);
    }
}

void GameMainScreen(uchar command, bit flag)
{
    uchar x, y;
    for (x = 0; x < 5; x ++)
    {
        for (y = 0; y < 5; y ++)
        {
            DrawRect(14 + x, 12 + y, 114 - x, 52 - y);;
        }
        
    }

    for (x = 20; x < 110; x ++)
    {
        for (y = 17; y < 47; y ++)
        {
            LCM_pixel(x, y, 0);
        }
    }

    if (command == QUIT)
    {
        LCM_print_ram(3,3, "Really to");
        LCM_print_ram(3,4, "quit game?");
        return;
    }
    else if (command == PAUSE)
    {
        LCM_print_ram(3, 3, "Pause");
        return;
    }
    else if (flag == 1)//game is over
    {
        for (y = 0; y < CUBE_COUNT_Y; y ++)
        {
            for (x = 0; x < CUBE_COUNT_X; x ++)
            {
                SetGameBoardCubeBit(game_board_cube, x, y, 1);
                DrawCube(game_board_cube, x, y);
            }
        }
        for (x = 20; x < 110; x ++)
        {
            for (y = 17; y < 47; y ++)
            {
                LCM_pixel(x, y, 0);
            }
        }
        LCM_print_ram(3, 3,"Continue?");
    }
    else if (flag == 0)//start the game
    {
        LCM_print_ram(3,3,"Welcome to");
        LCM_print_ram(3,4,"play the");
        LCM_print_ram(3,5,"Game!");
        LCM_print_ram(3,7,"Select Level");
    }
}
void PrintMyInfo()
{
    LCM_print_ram(7,6,"08011122");
    LCM_print_ram(7,7, "czx");
}

void RestartInit()
{
    uchar y = 0;
    for (y = 0; y < CUBE_COUNT_Y; y ++)
    {
        game_board_cube[y] = 0;
    }
    command = NO_ACTION;
    LCM_clear_text();
    LCM_clear_graph1();
    LCM_clear_ram();
    PrintMyInfo();
}

//t6963.c LCD12864驱动(该部分不是本人写的)

#include <reg51.h>
#include <absacc.h>

#include "variable.h"

//端口定义
#define LCMDW        XBYTE[0x0f200]        // 数据口
#define LCMCW        XBYTE[0x0f201]        // 命令口

// T6963C 命令定义
#define LCM_CUR_POS    0x21               // 光标位置设置
#define LCM_CGR_POS    0x22               // CGRAM偏置地址设置
#define LCM_ADD_POS    0x24               // 地址指针位置
#define LCM_TXT_STP    0x40               // 文本区首址
#define LCM_TXT_WID    0x41               // 文本区宽度
#define LCM_GRH_STP    0x42               // 图形区首址
#define LCM_GRH_WID    0x43               // 图形区宽度
#define LCM_MOD_OR    0x80               // 显示方式:逻辑"或"
#define LCM_MOD_XOR    0x81               // 显示方式:逻辑"异或"
#define LCM_MOD_AND    0x83               // 显示方式:逻辑"与"
#define LCM_MOD_TCH    0x84               // 显示方式:文本特征
#define LCM_DIS_SW    0x90             // 显示开关:D0=1/0:光标闪烁启用/禁用;
                                 // D1=1/0:光标显示启用/禁用;
                                 // D2=1/0:文本显示启用/禁用;
                                 // D3=1/0:图形显示启用/禁用;
#define LCM_CUR_SHP    0xA0          //光标形状选择:0xA0-0xA7表示光标占的行数
#define LCM_AUT_WR    0xB0          // 自动写设置
#define LCM_AUT_RD    0xB1              // 自动读设置
#define LCM_AUT_OVR    0xB2              // 自动读/写结束
#define LCM_INC_WR    0xC0              // 数据一次写,地址加1
#define LCM_INC_RD    0xC1              // 数据一次读,地址加1
#define LCM_DEC_WR    0xC2              // 数据一次写,地址减1
#define LCM_DEC_RD    0xC3              // 数据一次读,地址减1
#define LCM_NOC_WR    0xC4              // 数据一次写,地址不变
#define LCM_NOC_RD    0xC5              // 数据一次读,地址不变
#define LCM_SCN_RD    0xE0              // 屏读
#define LCM_SCN_CP    0xE8              // 屏拷贝
#define LCM_BIT_OP    0xF0              // 位操作:D0-D2:定义D0-D7位;D3:1置位;0:清除 

/* ----- 定义液晶屏内部RAM  ------ */
#define LCM_T_BASE 0x00            // 文本区内存首地址
#define LCM_G_BASE 0x10            // 图形区内存首地址
#define LCM_BYTES_PER_ROW  16         // 定义屏幕文本宽度为16字节

#define LCM_G_BASE_BUFF 0x10
// 绘图坐标限制
#define LCM_XMAX 128  
#define LCM_XMIN 0
#define LCM_YMAX 64
#define LCM_YMIN 0



//typedef unsigned char uchar;
//typedef unsigned int uint;
//typedef unsigned long ulong;


// 判准备好子程序
uchar fnST01(void)                  // 状态位STA1,STA0判断(读写指令和读写数据)
{
    uchar i;    
    for(i=10;i>0;i--)
    {
        if((LCMCW & 0x03) == 0x03)
            break;
    }
    return i;                          // 若返回零,说明错误
}

uchar fnST2(void)                     // 状态位ST2判断(数据自动读状态)
{
    uchar i;
    
    for(i=10;i>0;i--)
    {
        if((LCMCW & 0x04) == 0x04)
            break;
    }
    return i;                         // 若返回零,说明错误
}

uchar fnST3(void)                         // 状态位ST3判断(数据自动写状态)
{
    uchar i;
    
    for(i=10;i>0;i--)
    {
        if((LCMCW & 0x08) == 0x08)
            break;
    }
    return i;                                // 若返回零,说明错误
}

uchar fnST6(void)                             // 状态位ST6判断(屏读/屏拷贝状态)
{
    uchar i;
    
    for(i=10;i>0;i--)
    {
        if((LCMCW & 0x40) == 0x40)
            break;
    }
    return i;                                   // 若返回零,说明错误
}

uchar fnPR10(uchar uCmd,uchar uPar1,uchar uPar2)    // 写双参数的指令
{
    if(fnST01() == 0)
        return 1;
    LCMDW = uPar1;
    if(fnST01() == 0)
        return 2;
    LCMDW = uPar2;
    if(fnST01() == 0)
        return 3;
    LCMCW = uCmd;
    return 0;                               // 返回0成功
}

uchar fnPR11(uchar uCmd,uchar uPar1)       // 写单参数的指令
{
    if(fnST01() == 0)
        return 1;
    LCMDW = uPar1;
    if(fnST01() == 0)
        return 2;
    LCMCW = uCmd;
    return 0;                                // 返回0成功
}

uchar fnPR12(uchar uCmd)                   // 写无参数的指令
{
    if(fnST01() == 0)
        return 1;
    LCMCW = uCmd;
    return 0;                                  // 返回0成功
}

uchar fnPR13(uchar uData)                      // 一次写数据
{
    if(fnST01() == 0)
        return 1;
    LCMDW = uData;
    return 0;                                   // 返回0成功
}

uchar fnPR14(uchar uData)                      // 自动写数据
{
    if(fnST3() == 0)
        return 1;
    LCMDW = uData;
    return 0;                                   // 返回0成功
}

uchar fnPR2(void)                               // 一次读数据
{
    if(fnST01() == 0)
        return 1;
    return LCMDW;
}

void LCM_set_address(uint addr)
{ 
    fnPR10(LCM_ADD_POS, addr & 0xFF, addr / 256);   //0x24为设定地址命令
}

//文本方式设置显示坐标
void LCM_xy(uchar x, uchar y)
{
    uint  addr;
    addr = 0x5000 + LCM_T_BASE + (y * LCM_BYTES_PER_ROW) + x;
    LCM_set_address(addr);        // 设置显示地址
}


//文本清屏
void LCM_clear_text(void)
{
    uint  i;
    fnPR10(LCM_ADD_POS, LCM_T_BASE,0x50);       // 置地址指针
    fnPR12(LCM_AUT_WR);           // 自动写
    for(i=0;i<16*8*8;i++)
    {
        fnST3();
        fnPR14(0x00);               // 写数据
    }
    fnPR12(LCM_AUT_OVR);           // 自动写结束
    fnPR10(LCM_ADD_POS, LCM_T_BASE,0x00);       // 重置地址指针}
}

// 图形清屏
void LCM_clear_graph1(void) 
{
    uint  i;
    fnPR10(LCM_ADD_POS, LCM_G_BASE,0x00);       // 置地址指针
    
//    fnPR10(LCM_ADD_POS, LCM_G_BASE_BUFF,0x00);
    fnPR12(LCM_AUT_WR);           // 自动写
    for(i=0;i<16*8*8;i++)
    {
        fnST3();
        fnPR14(0x00);               // 写数据
    }
    fnPR12(LCM_AUT_OVR);           // 自动写结束
    fnPR10(LCM_ADD_POS, LCM_G_BASE,0x00);       // 重置地址指针
}

//清全部32KB内存
void LCM_clear_ram(void)  
{
    uint  i;
    fnPR10(LCM_ADD_POS, 0x00,0x00);       // 置地址指针
    fnPR12(LCM_AUT_WR);           // 自动写
    for(i=0;i<8000;i++)
    {
        fnST3();
        fnPR14(0x00);               // 写数据
    }
    fnPR12(LCM_AUT_OVR);           // 自动写结束
    fnPR10(LCM_ADD_POS, 0x00,0x00);       // 重置地址指针
}

// 初始化显存和显示模式
uchar LCM_init (void)
{
    if(fnPR10(LCM_TXT_STP, LCM_T_BASE,0x50) != 0)    // 文本显示区首地址
        return  -1;
    fnPR10(LCM_TXT_WID, LCM_BYTES_PER_ROW,0x00);          // 文本显示区宽度
    fnPR10(LCM_GRH_STP, LCM_G_BASE,0x00);            // 图形显示区首地址
//    fnPR10(LCM_GRH_STP, LCM_G_BASE_BUFF,0x00);    

    fnPR10(LCM_GRH_WID, LCM_BYTES_PER_ROW,0x00);         // 图形显示区宽度
    fnPR12(LCM_CUR_SHP | 0x07);        // 光标形状
    fnPR10(LCM_ADD_POS, 0x00,0x00);   // 光标位置设置
    fnPR12(LCM_MOD_OR);                // 显示方式设置
    fnPR12(LCM_DIS_SW | 0x0c);            //显示设置为:图形开、文本开
     // 注意:如果设置显示光标,需要设定光标的位置
    return 0;
}

// 显示字符串RAM
void LCM_print_ram(uchar x,uchar y, uchar *string)  
{
     uchar i,c;
     LCM_xy(x,y);
    fnPR12(LCM_AUT_WR);           // 自动写
     for (i=0;string[i]!=0;i++)
     {
          c = string[i] - 0x20;     // 转换ASCII码为屏幕内码
        fnPR14(c);                     // 写数据
     }
    fnPR12(LCM_AUT_OVR);           // 自动写结束
}

void LCM_pixel(uchar column, uchar row, uchar show)
{
     int addr;       // memory address of byte containing pixel to write
     if( (column>=LCM_XMAX) || (row>=LCM_YMAX) )
        return;
     
//    addr =  LCM_G_BASE_BUFF + (row*LCM_BYTES_PER_ROW)  + (column/8);
    addr =  LCM_G_BASE + (row*LCM_BYTES_PER_ROW)  + (column/8);
     LCM_set_address(addr);   // set LCD addr. Pointer
     if(show)
    {
        
        LCM_set_address(addr);
        fnPR12(0xf8+7-column%8);
    }
         
     else
    {
        LCM_set_address(addr);
        fnPR12(0xf0+7-column%8);
    }
         
}

 

 

 

基于51的俄罗斯方块,布布扣,bubuko.com

基于51的俄罗斯方块

标签:style   class   blog   code   tar   ext   

原文地址:http://www.cnblogs.com/chenzongxiong/p/3795201.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!