忙里偷闲，消遣一下，先上一张寒酸的效果图：

废话不多说，直接上代码，win7 64 code blocks编译通过。

吐槽一下cb的watch功能实在不够友好，不过免费的也不能要求太高。

【按键说明】

A：向左

D：向右

S：向下

Space：变化

#include "stdio.h"

#include "stdlib.h"

#include "windows.h"

#include "time.h"

// ----------------------------------------------------------------------------

//                 local define

// ----------------------------------------------------------------------------

#define _KEY_DOWN           's'

#define _KEY_LEFT           'a'

#define _KEY_RIGHT          'd'

#define _KEY_CHANGE         ' '

#define _BLOCK_X_MAX        20

#define _BLOCK_Y_MAX        20

#define _BLOCK_UNIT_NONE    ' '

#define _BLOCK_UNIT_TETRIS  '@'

#define _BLOCK_UNIT_EDGE    '*'

#define _TETRIS_BUF_SIZE    4

#define _TETRIS_TYPE_NUM    7

#define _TETRIS_SPEED       600

#define _CHANGE_TIME_MAX    4

// ----------------------------------------------------------------------------

//                 local type

// ----------------------------------------------------------------------------

typedef unsigned char     BYTE;

typedef unsigned short    WORD;

typedef unsigned long     DWORD;

typedef unsigned char  *  PBYTE;

typedef unsigned short *  PWORD;

typedef unsigned long  *  PDWORD;

typedef enum

{

    _E_KT_NONE,

    _E_KT_DOWN,

    _E_KT_LEFT,

    _E_KT_RIGHT,

    _E_KT_CHANGE,

    _E_KT_SIZE

}E_KEY_TYPE;

typedef struct

{

    int i_x;

    int i_y;

}T_Tetris_Unit_Pos;

// ----------------------------------------------------------------------------

//                 local vars

// ----------------------------------------------------------------------------

const T_Tetris_Unit_Pos __DB[_TETRIS_TYPE_NUM][_TETRIS_BUF_SIZE] =

{

/*

 @@

  @@

 */

{{_BLOCK_X_MAX/2, 0},{_BLOCK_X_MAX/2+1, 0},{_BLOCK_X_MAX/2+1, 1},{_BLOCK_X_MAX/2+2, 1}},

/*

  @@

 @@

 */

{{_BLOCK_X_MAX/2+1, 0},{_BLOCK_X_MAX/2+2, 0},{_BLOCK_X_MAX/2, 1},{_BLOCK_X_MAX/2+1, 1}},

/*

  @

 @@@

 */

{{_BLOCK_X_MAX/2, 0},{_BLOCK_X_MAX/2-1, 1},{_BLOCK_X_MAX/2, 1},{_BLOCK_X_MAX/2+1, 1}},

/*

   @

 @@@

 */

{{_BLOCK_X_MAX/2, 0},{_BLOCK_X_MAX/2-2, 1},{_BLOCK_X_MAX/2-1, 1},{_BLOCK_X_MAX/2, 1}},

/*

 @

 @@@

 */

{{_BLOCK_X_MAX/2, 0},{_BLOCK_X_MAX/2, 1},{_BLOCK_X_MAX/2+1, 1},{_BLOCK_X_MAX/2+2, 1}},

/*

 @@

 @@

 */

{{_BLOCK_X_MAX/2, 0},{_BLOCK_X_MAX/2+1, 0},{_BLOCK_X_MAX/2, 1},{_BLOCK_X_MAX/2+1, 1}},

/*

 @@@@

 */

{{_BLOCK_X_MAX/2, 1},{_BLOCK_X_MAX/2+1, 1},{_BLOCK_X_MAX/2+2, 1},{_BLOCK_X_MAX/2+3, 1}},

};

const DWORD __OFFSET[_TETRIS_TYPE_NUM][_CHANGE_TIME_MAX] =

{

/*

 @@

  @@

 */

{0x00101121, 0x10110102, 0x00101121, 0x10110102},

/*

  @@

 @@

 */

{0x10200111, 0x01001211, 0x10200111, 0x01001211},

/*

  @

 @@@

 */

{0x10011121, 0x21101112, 0x12211101, 0x01121110},

/*

   @

 @@@

 */

{0x20011121, 0x22101112, 0x02211101, 0x00121110},

/*

 @

 @@@

 */

{0x00011121, 0x10000102, 0x21201000, 0x02121110},

/*

 @@

 @@

 */

{0x00000000, 0x00000000, 0x00000000, 0x00000000},

/*

 @@@@

 */

{0x01112131, 0x00010203, 0x01112131, 0x00010203},

};

T_Tetris_Unit_Pos l_at_cur_tetris[_TETRIS_BUF_SIZE];

BYTE l_by_offset_index = 0;

BYTE l_by_db_index = 0;

BYTE l_aby_block[_BLOCK_Y_MAX][_BLOCK_X_MAX];

// ----------------------------------------------------------------------------

//                 funcs part

// ----------------------------------------------------------------------------

void Pos_Jump(int x, int y)

{

    COORD  pos  = {x, y};

    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

    SetConsoleCursorPosition(hOut, pos);

}

void Pos_Jump_In_Block(int x, int y)

{

    Pos_Jump(x+1, y+1);

}

E_KEY_TYPE Key_Detect()

{

    BYTE       by_key_value;

    E_KEY_TYPE e_kt;

    if(0 == kbhit())

    {

        return _E_KT_NONE;

    }

    by_key_value = (BYTE)(getch());

/*

    if(l_b_key_lock)

    {

        return _E_KT_NONE;

    }

*/

    switch(by_key_value)

    {

    case _KEY_DOWN:

        e_kt = _E_KT_DOWN;

        break;

    case _KEY_LEFT:

        e_kt = _E_KT_LEFT;

        break;

    case _KEY_RIGHT:

        e_kt = _E_KT_RIGHT;

        break;

    case _KEY_CHANGE:

        e_kt = _E_KT_CHANGE;

        break;

    default:

        e_kt = _E_KT_NONE;

        break;

    }

    return e_kt;

}

void Show_Block()

{

    int i, j;

    // set default value -----

    for(i=0 ; i<_BLOCK_Y_MAX ; i++)

    {

        for(j=0 ; j<_BLOCK_X_MAX ; j++)

        {

            l_aby_block[i][j] = _BLOCK_UNIT_NONE;

        }

    }

    // show frame -------

    // top

    Pos_Jump(0, 0);

    for(i=0 ; i<_BLOCK_X_MAX+2 ; i++)

    {

        printf("%c", _BLOCK_UNIT_EDGE);

    }

    // bottom

    Pos_Jump(0, _BLOCK_Y_MAX+1);

    for(i=0 ; i<_BLOCK_X_MAX+2 ; i++)

    {

        printf("%c", _BLOCK_UNIT_EDGE);

    }

    // side

    for(j=1 ; j<_BLOCK_Y_MAX+1 ; j++)

    {

        Pos_Jump(0, j);

        printf("%c", _BLOCK_UNIT_EDGE);

        Pos_Jump(_BLOCK_X_MAX+1, j);

        printf("%c", _BLOCK_UNIT_EDGE);

    }

}

BOOL Get_New()

{

    int i_type_num;

    int i;

    srand(time(0));

    i_type_num = rand()%(_TETRIS_TYPE_NUM);

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        l_at_cur_tetris[i] = __DB[i_type_num][i];

    }

    l_by_offset_index = 0;

    l_by_db_index = i_type_num;

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        if(_BLOCK_UNIT_TETRIS == l_aby_block[l_at_cur_tetris[i].i_y][l_at_cur_tetris[i].i_x])

        {

            return FALSE;

        }

    }

    return TRUE;

}

void Clear_Cur_Tetris()

{

    int i;

    // draw new ----------

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        Pos_Jump_In_Block(l_at_cur_tetris[i].i_x, l_at_cur_tetris[i].i_y);

        printf(" ");

    }

}

void Show_Cur_Tetris()

{

    int i;

    // draw new ----------

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        Pos_Jump_In_Block(l_at_cur_tetris[i].i_x, l_at_cur_tetris[i].i_y);

        printf("@");

    }

}

void Move_Left()

{

    int i;

    T_Tetris_Unit_Pos at_next[_TETRIS_BUF_SIZE];

    // calc next ---

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        at_next[i] = l_at_cur_tetris[i];

        if(0 == at_next[i].i_x)

        {

            return;

        }

        at_next[i].i_x--;

    }

    // clear old ---------

    Clear_Cur_Tetris();

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        l_at_cur_tetris[i] = at_next[i];

    }

    Show_Cur_Tetris();

}

void Move_Right()

{

    int i;

    T_Tetris_Unit_Pos at_next[_TETRIS_BUF_SIZE];

    // calc next ---

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        at_next[i] = l_at_cur_tetris[i];

        at_next[i].i_x++;

        if(_BLOCK_X_MAX == at_next[i].i_x)

        {

            return;

        }

    }

    // clear old ---------

    Clear_Cur_Tetris();

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        l_at_cur_tetris[i] = at_next[i];

    }

    Show_Cur_Tetris();

}

BOOL Move_Down()

{

    int i;

    T_Tetris_Unit_Pos at_next[_TETRIS_BUF_SIZE];

    BOOL b_can_down = FALSE;

    // calc next ---

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        at_next[i] = l_at_cur_tetris[i];

        at_next[i].i_y++;

    }

    // check if next is ok ---

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        if(  _BLOCK_UNIT_TETRIS == l_aby_block[at_next[i].i_y][at_next[i].i_x]

           ||_BLOCK_Y_MAX == at_next[i].i_y)

        {

            b_can_down = FALSE;

            return b_can_down;

        }

    }

    // clear old ---------

    Clear_Cur_Tetris();

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        l_at_cur_tetris[i] = at_next[i];

    }

    Show_Cur_Tetris();

    b_can_down = TRUE;

    return b_can_down;

}

void On_Change()

{

    int i;

    DWORD dw_cur, dw_next;

    int i_x_offset, i_y_offset;

    int i_x_min, i_x_max;

    T_Tetris_Unit_Pos at_next[_TETRIS_BUF_SIZE];

    if(_CHANGE_TIME_MAX-1 != l_by_offset_index)

    {

        dw_cur = __OFFSET[l_by_db_index][l_by_offset_index];

        dw_next = __OFFSET[l_by_db_index][l_by_offset_index+1];

    }

    else

    {

        dw_cur = __OFFSET[l_by_db_index][_CHANGE_TIME_MAX-1];

        dw_next = __OFFSET[l_by_db_index][0];

    }

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        i_x_offset = (int)(((dw_next>>8*(4-i-1))&0xF0)>>4) - (int)(((dw_cur>>8*(4-i-1))&0xF0)>>4);

        i_y_offset = (int)((dw_next>>8*(4-i-1))&0x0F) - (int)((dw_cur>>8*(4-i-1))&0x0F);

        at_next[i] = l_at_cur_tetris[i];

        at_next[i].i_x += i_x_offset;

        at_next[i].i_y += i_y_offset;

    }

    // check ------

    i_x_min = at_next[0].i_x;

    i_x_max = at_next[0].i_x;

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        if(i_x_min > at_next[i].i_x)

        {

           i_x_min = at_next[i].i_x;

        }

        if(i_x_max < at_next[i].i_x)

        {

           i_x_max = at_next[i].i_x;

        }

    }

    if(i_x_min < 0)

    {

        for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

        {

            at_next[i].i_x -= i_x_min;

        }

    }

    if(i_x_max > _BLOCK_X_MAX-1)

    {

        for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

        {

            at_next[i].i_x -= i_x_max - (_BLOCK_X_MAX-1);

        }

    }

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        if(_BLOCK_UNIT_TETRIS == l_aby_block[at_next[i].i_x][at_next[i].i_y])

        {

            // can not change -------

            return;

        }

    }

    // ----------------

    l_by_offset_index++;

    l_by_offset_index = l_by_offset_index % _CHANGE_TIME_MAX;

    Clear_Cur_Tetris();

    for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

    {

        l_at_cur_tetris[i] = at_next[i];

    }

    Show_Cur_Tetris();

}

void On_Key_Detecting()

{

    E_KEY_TYPE e_type;

    e_type = Key_Detect();

    if(_E_KT_NONE == e_type)

    {

        return;

    }

    if(_E_KT_CHANGE == e_type)

    {

        On_Change();

    }

    if(_E_KT_LEFT == e_type)

    {

        Move_Left();

    }

    if(_E_KT_RIGHT == e_type)

    {

        Move_Right();

    }

    if(_E_KT_DOWN == e_type)

    {

        Move_Down();

    }

}

void Show_Game_Over()

{

    Pos_Jump(0, _BLOCK_Y_MAX+2);

    printf("Game Over!!!");

}

BOOL On_Timer()

{

    static DWORD dw_time_cur  = 0;

    static DWORD dw_time_last = 0;

    int i;

    // check speed

    dw_time_cur = GetTickCount();

    if(dw_time_cur < dw_time_last + _TETRIS_SPEED)

    {

        return FALSE;

    }

    dw_time_last = dw_time_cur;

    if(FALSE == Move_Down())

    {

        for(i=0 ; i<_TETRIS_BUF_SIZE ; i++)

        {

            l_aby_block[l_at_cur_tetris[i].i_y][l_at_cur_tetris[i].i_x] = _BLOCK_UNIT_TETRIS;

        }

        if(FALSE == Get_New())

        {

            Show_Cur_Tetris();

            return TRUE;

        }

    }

    return FALSE;

}

void Line_Blink(int y, BOOL b_show)

{

    int i;

    // draw new ----------

    Pos_Jump_In_Block(0, y);

    for(i=0 ; i<_BLOCK_X_MAX ; i++)

    {

        if(b_show)

        {

            printf("%c", _BLOCK_UNIT_TETRIS);

        }

        else

        {

            printf("%c", _BLOCK_UNIT_NONE);

        }

    }

}

void Eliminate()

{

    int i, j, k;

    int i_blink_times;

    BOOL ab_eliminate_flag[_BLOCK_Y_MAX], b_need_blink = FALSE;

    DWORD dw_blink_time = 200;

    DWORD dw_time_cur;

    // check which line need to eliminate ------

    for(j=0 ; j<_BLOCK_Y_MAX ; j++)

    {

        ab_eliminate_flag[j] = TRUE;

        for(i=0 ; i<_BLOCK_X_MAX ; i++)

        {

            if('@' != l_aby_block[j][i])

            {

                ab_eliminate_flag[j] = FALSE;

                break;

            }

        }

        if(ab_eliminate_flag[j])

        {

            b_need_blink = TRUE;

        }

    }

    if(FALSE == b_need_blink)

    {

        return;

    }

    // blink -----------

    i_blink_times = 3;

    for(i=0 ; i<i_blink_times ; i++)

    {

        dw_time_cur = GetTickCount();

        while(TRUE)

        {

            if((dw_time_cur + dw_blink_time) < GetTickCount())

            {

                break;

            }

        }

        for(j=0 ; j<_BLOCK_Y_MAX ; j++)

        {

            if(ab_eliminate_flag[j])

            {

                Line_Blink(j, FALSE);

            }

        }

        dw_time_cur = GetTickCount();

        while(TRUE)

        {

            if((dw_time_cur + dw_blink_time) < GetTickCount())

            {

                break;

            }

        }

        for(j=0 ; j<_BLOCK_Y_MAX ; j++)

        {

            if(ab_eliminate_flag[j])

            {

                Line_Blink(j, TRUE);

            }

        }

    }

    // remove ----------

    for(j=0 ; j<_BLOCK_Y_MAX ; j++)

    {

        if(ab_eliminate_flag[j])

        {

            for(i=0 ; i<_BLOCK_X_MAX ; i++)

            {

                l_aby_block[j][i] = ' ';

            }

            for(k=j ; k>0 ; k--)

            {

                for(i=0 ; i<_BLOCK_X_MAX ; i++)

                {

                    l_aby_block[k][i] = l_aby_block[k-1][i];

                }

            }

        }

    }

    for(j=0 ; j<_BLOCK_Y_MAX ; j++)

    {

        Pos_Jump_In_Block(0, j);

        for(i=0 ; i<_BLOCK_X_MAX ; i++)

        {

            printf("%c", l_aby_block[j][i]);

        }

    }

}

int main()

{

    BOOL b_game_over;

    Show_Block();

    Get_New();

    Show_Cur_Tetris();

    while(TRUE)

    {

        On_Key_Detecting();

        b_game_over = On_Timer();

        if(b_game_over)

        {

            Show_Game_Over();

            break;

        }

        Eliminate();

    }

    getch();

    return 0;

}