俄羅斯方塊源碼

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <windows.h>

#ifdef _MSC_VER  // M$的編譯器要給予特殊照顧
    #if _MSC_VER <= 1200  // VC6及以下版本
        #error 你是不是還在用VC6？！
    #else  // VC6以上版本
        #if _MSC_VER >= 1600  // 據說VC10及以上版本有stdint.h了
            #include <stdint.h>
        #else  // VC10以下版本，自己定義int8_t和uint16_t
            typedef signed char int8_t;
            typedef unsigned short uint16_t;
        #endif
        #ifndef __cplusplus  // 據說VC都沒有stdbool.h，不用C++編譯，自己定義bool
            typedef int bool;
            #define true 1
            #define false 0
        #endif
    #endif
#else  // 其他的編譯器都好說
    #include <stdint.h>
    #ifndef __cplusplus  // 不用C++編譯，需要stdbool.h裏的bool
        #include <stdbool.h>
    #endif
#endif

// 方塊形狀
enum { TETRIS_I = 0, TETRIS_T, TETRIS_L, TETRIS_J, TETRIS_Z, TETRIS_S, TETRIS_O };

// =============================================================================
// 7種方塊的4旋轉狀態（4位爲一行）
static const uint16_t gs_uTetrisTable[7][4] =
{
    { 0x00F0U, 0x2222U, 0x00F0U, 0x2222U },  // I型
    { 0x0072U, 0x0262U, 0x0270U, 0x0232U },  // T型
    { 0x0223U, 0x0074U, 0x0622U, 0x0170U },  // L型
    { 0x0226U, 0x0470U, 0x0322U, 0x0071U },  // J型
    { 0x0063U, 0x0264U, 0x0063U, 0x0264U },  // Z型
    { 0x006CU, 0x0462U, 0x006CU, 0x0462U },  // S型
    { 0x0660U, 0x0660U, 0x0660U, 0x0660U }   // O型
};

// =============================================================================
// 初始狀態的遊戲池
// 每個元素表示遊戲池的一行，下標大的是遊戲池底部
// 兩端各置2個1，底部2全置爲1，便於進行碰撞檢測
// 由於左端只有2個1，要保證所有方塊的x座標大於0，否則位操作時會出BUG
// 這樣一來遊戲池的寬度爲12列
// 如果想要傳統的10列，只需多填兩個1即可（0xE007），當然顯示相關部分也要隨之改動
// 當某個元素爲0xFFFFU時，說明該行已被填滿
// 頂部4行用於給方塊，不顯示出來
// 再除去底部2行，顯示出來的遊戲池高度爲22行
static const uint16_t gs_uInitialTetrisPool[28] =
{
    0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U,
    0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U,
    0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U,
    0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xFFFFU, 0xFFFFU
};

#define COL_BEGIN 2
#define COL_END 14
#define ROW_BEGIN 4
#define ROW_END 26

// =============================================================================
typedef struct TetrisManager  // 這個結構體存儲遊戲相關數據
{
    uint16_t pool[28];  // 遊戲池
    int8_t x;  // 當前方塊x座標，此處座標爲方塊左上角座標
    int8_t y;  // 當前方塊y座標
    int8_t type[3];  // 當前、下一個和下下一個方塊類型
    int8_t orientation[3];  // 當前、下一個和下下一個方塊旋轉狀態
} TetrisManager;

// =============================================================================
typedef struct TetrisControl  // 這個結構體存儲控制相關數據
{
    // 遊戲池內每格的顏色
    // 由於此版本是彩色的，僅用遊戲池數據無法存儲顏色信息
    // 當然，如果只實現單色版的，就沒必要用這個數組了
    int8_t color[28][16];
    bool dead;  // 掛
    bool pause;  // 暫停
    bool clockwise;  // 旋轉方向：順時針爲true
    int8_t direction;  // 移動方向：0向左移動 1向右移動
    bool model;  // 模式 遊戲模式爲false
    unsigned score;  // 得分
    unsigned erasedCount[4];  // 消行數
    unsigned erasedTotal;  // 消行總數
    unsigned tetrisCount[7];  // 各方塊數
    unsigned tetrisTotal;  // 方塊總數
} TetrisControl;

HANDLE g_hConsoleOutput;  // 控制檯輸出句柄

// =============================================================================
// 函數聲明
// 如果使用全局變量方式實現，就沒必要傳參了
void initGame(TetrisManager *manager, TetrisControl *control, bool model);  // 初始化遊戲
void giveTetris(TetrisManager *manager, TetrisControl *control);  // 給一個方塊
bool checkCollision(const TetrisManager *manager);  // 碰撞檢測
void insertTetris(TetrisManager *manager);  // 插入方塊
void removeTetris(TetrisManager *manager);  // 移除方塊
void horzMoveTetris(TetrisManager *manager, TetrisControl *control);  // 水平移動方塊
void moveDownTetris(TetrisManager *manager, TetrisControl *control);  // 向下移動方塊
void rotateTetris(TetrisManager *manager, TetrisControl *control);  // 旋轉方塊
void dropDownTetris(TetrisManager *manager, TetrisControl *control);  // 方塊直接落地
bool checkErasing(TetrisManager *manager, TetrisControl *control);  // 消行檢測
void keydownControl(TetrisManager *manager, TetrisControl *control, int key);  // 鍵按下
void setPoolColor(const TetrisManager *manager, TetrisControl *control);  // 設置顏色
void gotoxyWithFullwidth(short x, short y);  // 以全角定位到某點
void printPoolBorder();  // 顯示遊戲池邊界
void printTetrisPool(const TetrisManager *manager, const TetrisControl *control);  // 顯示遊戲池
void printCurrentTetris(const TetrisManager *manager, const TetrisControl *control);  // 顯示當前方塊
void printNextTetris(const TetrisManager *manager);  // 顯示下一個和下下一個方塊
void printScore(const TetrisManager *manager, const TetrisControl *control);  // 顯示得分信息
void runGame(TetrisManager *manager, TetrisControl *control);  // 運行遊戲
void printPrompting();  // 顯示提示信息
int mainMenu();  // 主菜單
void autoRun(TetrisManager *manager, TetrisControl *control);  // 自動運行

// =============================================================================
// 主函數
int main()
{
    int model;
    TetrisManager tetrisManager;
    TetrisControl tetrisControl;
    CONSOLE_CURSOR_INFO cursorInfo = { 1, FALSE };  // 光標信息

    g_hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);  // 獲取控制檯輸出句柄
    SetConsoleCursorInfo(g_hConsoleOutput, &cursorInfo);  // 設置光標隱藏
    SetConsoleTitleA("俄羅斯方塊控制檯版——By: wohaaitinciu");

    do
    {
        model = mainMenu();
        SetConsoleTextAttribute(g_hConsoleOutput, 0x07);
        system("cls");
        initGame(&tetrisManager, &tetrisControl, model == 0);  // 初始化遊戲
        printPrompting();  // 顯示提示信息
        printPoolBorder();  // 顯示遊戲池邊界

        if (model == 0)
        {
            runGame(&tetrisManager, &tetrisControl);  // 運行遊戲
        }
        else
        {
            autoRun(&tetrisManager, &tetrisControl);  // 自動運行
        }

        SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
        gotoxyWithFullwidth(13, 10);
        printf("按任意鍵回主菜單");
        SetConsoleTextAttribute(g_hConsoleOutput, 0x07);
        system("pause > nul");
        system("cls");

    } while (1);

    gotoxyWithFullwidth(0, 0);
    CloseHandle(g_hConsoleOutput);
    return 0;
}

// =============================================================================
// 初始化遊戲
void initGame(TetrisManager *manager, TetrisControl *control, bool model)
{
    memset(manager, 0, sizeof(TetrisManager));  // 全部置0

    // 初始化遊戲池
    memcpy(manager->pool, gs_uInitialTetrisPool, sizeof(uint16_t [28]));
    srand((unsigned)time(NULL));  // 設置隨機種子

    manager->type[1] = rand() % 7;  // 下一個
    manager->orientation[1] = rand() & 3;

    manager->type[2] = rand() % 7;  // 下下一個
    manager->orientation[2] = rand() & 3;

    memset(control, 0, sizeof(TetrisControl));  // 全部置0
    control->model = model;

    giveTetris(manager, control);  // 給下一個方塊
    setPoolColor(manager, control);  // 設置顏色
    printScore(manager, control);  // 顯示得分信息
}

// =============================================================================
// 給一個方塊
void giveTetris(TetrisManager *manager, TetrisControl *control)
{
    uint16_t tetris;

    manager->type[0] = manager->type[1];  // 下一個方塊置爲當前
    manager->orientation[0] = manager->orientation[1];

    manager->type[1] = manager->type[2];// 下下一個置方塊爲下一個
    manager->orientation[1] = manager->orientation[2];

    manager->type[2] = rand() % 7;// 隨機生成下下一個方塊
    manager->orientation[2] = rand() & 3;

    tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];  // 當前方塊

    // 設置當前方塊y座標，保證剛給出時只顯示方塊最下面一行
    // 這種實現使得玩家可以以很快的速度將方塊落在不顯示出來的頂部4行內
    if (tetris & 0xF000)
    {
        manager->y = 0;
    }
    else
    {
        manager->y = (tetris & 0xFF00) ? 1 : 2;
    }
    manager->x = 6;  // 設置當前方塊x座標

    if (checkCollision(manager))  // 檢測到碰撞
    {
        control->dead = true;  // 標記遊戲結束
    }
    else  // 未檢測到碰撞
    {
        insertTetris(manager);  // 將當前方塊加入遊戲池
    }

    ++control->tetrisTotal;  // 方塊總數
    ++control->tetrisCount[manager->type[0]];  // 相應方塊數

    printNextTetris(manager);  // 顯示下一個方塊
}

// =============================================================================
// 碰撞檢測
bool checkCollision(const TetrisManager *manager)
{
    // 當前方塊
    uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];
    uint16_t dest = 0U;

    // 獲取當前方塊在遊戲池中的區域：
    // 遊戲池座標x y處小方格信息，按低到高存放在16位無符號數中
    dest |= (((manager->pool[manager->y + 0] >> manager->x) << 0x0) & 0x000F);
    dest |= (((manager->pool[manager->y + 1] >> manager->x) << 0x4) & 0x00F0);
    dest |= (((manager->pool[manager->y + 2] >> manager->x) << 0x8) & 0x0F00);
    dest |= (((manager->pool[manager->y + 3] >> manager->x) << 0xC) & 0xF000);

    // 若當前方塊與目標區域存在重疊（碰撞），則位與的結果不爲0
    return ((dest & tetris) != 0);
}

// =============================================================================
// 插入方塊
void insertTetris(TetrisManager *manager)
{
    // 當前方塊
    uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];

    // 當前方塊每4位取出，位或到遊戲池相應位置，即完成插入方塊
    manager->pool[manager->y + 0] |= (((tetris >> 0x0) & 0x000F) << manager->x);
    manager->pool[manager->y + 1] |= (((tetris >> 0x4) & 0x000F) << manager->x);
    manager->pool[manager->y + 2] |= (((tetris >> 0x8) & 0x000F) << manager->x);
    manager->pool[manager->y + 3] |= (((tetris >> 0xC) & 0x000F) << manager->x);
}

// =============================================================================
// 移除方塊
void removeTetris(TetrisManager *manager)
{
    // 當前方塊
    uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];

    // 當前方塊每4位取出，按位取反後位與到遊戲池相應位置，即完成移除方塊
    manager->pool[manager->y + 0] &= ~(((tetris >> 0x0) & 0x000F) << manager->x);
    manager->pool[manager->y + 1] &= ~(((tetris >> 0x4) & 0x000F) << manager->x);
    manager->pool[manager->y + 2] &= ~(((tetris >> 0x8) & 0x000F) << manager->x);
    manager->pool[manager->y + 3] &= ~(((tetris >> 0xC) & 0x000F) << manager->x);
}

// =============================================================================
// 設置顏色
void setPoolColor(const TetrisManager *manager, TetrisControl *control)
{
    // 由於顯示遊戲池時，先要在遊戲池裏判斷某一方格有方塊才顯示相應方格的顏色
    // 這裏只作設置即可，沒必要清除
    // 當移動方塊或給一個方塊時調用

    int8_t i, x, y;

    // 當前方塊
    uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];

    for (i = 0; i < 16; ++i)
    {
        y = (i >> 2) + manager->y;  // 待設置的列
        if (y > ROW_END)  // 超過底部限制
        {
            break;
        }
        x = (i & 3) + manager->x;  // 待設置的行
        if ((tetris >> i) & 1)  // 檢測的到小方格屬於當前方塊區域
        {
            control->color[y][x] = (manager->type[0] | 8);  // 設置顏色
        }
    }
}

// =============================================================================
// 旋轉方塊
void rotateTetris(TetrisManager *manager, TetrisControl *control)
{
    int8_t ori = manager->orientation[0];  // 記錄原旋轉狀態

    removeTetris(manager);  // 移走當前方塊

    // 順/逆時針旋轉
    manager->orientation[0] = (control->clockwise) ? ((ori + 1) & 3) : ((ori + 3) & 3);

    if (checkCollision(manager))  // 檢測到碰撞
    {
        manager->orientation[0] = ori;  // 恢復爲原旋轉狀態
        insertTetris(manager);  // 放入當前方塊。由於狀態沒改變，不需要設置顏色
    }
    else
    {
        insertTetris(manager);  // 放入當前方塊
        setPoolColor(manager, control);  // 設置顏色
        printCurrentTetris(manager, control);  // 顯示當前方塊
    }
}

// =============================================================================
// 水平移動方塊
void horzMoveTetris(TetrisManager *manager, TetrisControl *control)
{
    int x = manager->x;  // 記錄原列位置

    removeTetris(manager);  // 移走當前方塊
    control->direction == 0 ? (--manager->x) : (++manager->x);  // 左/右移動

    if (checkCollision(manager))  // 檢測到碰撞
    {
        manager->x = x;  // 恢復爲原列位置
        insertTetris(manager);  // 放入當前方塊。由於位置沒改變，不需要設置顏色
    }
    else
    {
        insertTetris(manager);  // 放入當前方塊
        setPoolColor(manager, control);  // 設置顏色
        printCurrentTetris(manager, control);  // 顯示當前方塊
    }
}

// =============================================================================
// 向下移動方塊
void moveDownTetris(TetrisManager *manager, TetrisControl *control)
{
    int8_t y = manager->y;  // 記錄原行位置

    removeTetris(manager);  // 移走當前方塊
    ++manager->y;  // 向下移動

    if (checkCollision(manager))  // 檢測到碰撞
    {
        manager->y = y;  // 恢復爲原行位置
        insertTetris(manager);  // 放入當前方塊。由於位置沒改變，不需要設置顏色
        if (checkErasing(manager, control))  // 檢測到消行
        {
            printTetrisPool(manager, control);  // 顯示遊戲池
        }
    }
    else
    {
        insertTetris(manager);  // 放入當前方塊
        setPoolColor(manager, control);  // 設置顏色
        printCurrentTetris(manager, control);  // 顯示當前方塊
    }
}

// =============================================================================
// 方塊直接落地
void dropDownTetris(TetrisManager *manager, TetrisControl *control)
{
    removeTetris(manager);  // 移走當前方塊

    // 從上往下檢測
    // 注意這裏不能從下往上，否則會出現方塊穿過蓋埋入空洞的BUG
    for (; manager->y < ROW_END; ++manager->y)
    {
        if (checkCollision(manager))  // 檢測到碰撞
        {
            break;
        }
    }
    --manager->y;  // 上移一格當然沒有碰撞

    insertTetris(manager);  // 放入當前方塊
    setPoolColor(manager, control);  // 設置顏色

    checkErasing(manager, control);  // 檢測消行
    printTetrisPool(manager, control);  // 顯示遊戲池
}

// =============================================================================
// 消行檢測
bool checkErasing(TetrisManager *manager, TetrisControl *control)
{
    static const unsigned scores[5] = { 0, 10, 30, 90, 150 };  // 消行得分
    int8_t count = 0;
    int8_t k = 0, y = manager->y + 3;

    do  // 從下往上檢測
    {
        if (y < ROW_END && manager->pool[y] == 0xFFFFU)  // 有效區域內且一行已填滿
        {
            ++count;
            // 消除一行方塊
            memmove(manager->pool + 1, manager->pool, sizeof(uint16_t) * y);
            // 顏色數組的元素隨之移動
            memmove(control->color[1], control->color[0], sizeof(int8_t [16]) * y);
        }
        else
        {
            --y;
            ++k;
        }
    } while (y >= manager->y && k < 4);

    control->erasedTotal += count;  // 消行總數
    control->score += scores[count];  // 得分

    if (count > 0)
    {
        ++control->erasedCount[count - 1];  // 消行
    }

    giveTetris(manager, control);  // 給下一個方塊
    setPoolColor(manager, control);  // 設置顏色
    printScore(manager, control);  // 顯示得分信息

    return (count > 0);
}

// =============================================================================
// 鍵按下
void keydownControl(TetrisManager *manager, TetrisControl *control, int key)
{
    if (key == 13)  // 暫停/解除暫停
    {
        control->pause = !control->pause;
    }

    if (control->pause)  // 暫停狀態，不作處理
    {
        return;
    }

    switch (key)
    {
    case 'w': case 'W': case '8': case 72:  // 上
        control->clockwise = true;  // 順時針旋轉
        rotateTetris(manager, control);  // 旋轉方塊
        break;
    case 'a': case 'A': case '4': case 75:  // 左
        control->direction = 0;  // 向左移動
        horzMoveTetris(manager, control);  // 水平移動方塊
        break;
    case 'd': case 'D': case '6': case 77:  // 右
        control->direction = 1;  // 向右移動
        horzMoveTetris(manager, control);  // 水平移動方塊
        break;
    case 's': case 'S': case '2': case 80:  // 下
        moveDownTetris(manager, control);  // 向下移動方塊
        break;
    case ' ':  // 直接落地
        dropDownTetris(manager, control);
        break;
    case '0':  // 反轉
        control->clockwise = false;  // 逆時針旋轉
        rotateTetris(manager, control);  // 旋轉方塊
        break;
    default:
        break;
    }
}

// =============================================================================
// 以全角定位到某點
void gotoxyWithFullwidth(short x, short y)
{
    static COORD cd;

    cd.X = (short)(x << 1);
    cd.Y = y;
    SetConsoleCursorPosition(g_hConsoleOutput, cd);
}

// =============================================================================
// 主菜單
int mainMenu()
{
    static const char *modelItem[] = { "1.遊戲模式", "2.觀看模式" };
    int index = 0, ch;

    SetConsoleTextAttribute(g_hConsoleOutput, 0x0F);
    gotoxyWithFullwidth(15, 5);
    printf("┏━━━━━━━┓");
    gotoxyWithFullwidth(15, 6);
    printf("┃%2s%s%2s┃", "", "俄羅斯方塊", "");
    gotoxyWithFullwidth(15, 7);
    printf("┗━━━━━━━┛");

    SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
    gotoxyWithFullwidth(16, 14);
    printf("%2s%s%2s", "", modelItem[0], "");
    SetConsoleTextAttribute(g_hConsoleOutput, 0x0F);
    gotoxyWithFullwidth(16, 16);
    printf("%2s%s%2s", "", modelItem[1], "");

    do
    {
        ch = _getch();
        switch (ch)
        {
        case 'w': case 'W': case '8': case 72:  // 上
        case 'a': case 'A': case '4': case 75:  // 左
        case 'd': case 'D': case '6': case 77:  // 右
        case 's': case 'S': case '2': case 80:  // 下
            if (index == 1)
            {
                index = 0;
                SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
                gotoxyWithFullwidth(16, 14);
                printf("%2s%s%2s", "", modelItem[0], "");
                SetConsoleTextAttribute(g_hConsoleOutput, 0x0F);
                gotoxyWithFullwidth(16, 16);
                printf("%2s%s%2s", "", modelItem[1], "");
            }
            else
            {
                index = 1;
                SetConsoleTextAttribute(g_hConsoleOutput, 0x0F);
                gotoxyWithFullwidth(16, 14);
                printf("%2s%s%2s", "", modelItem[0], "");
                SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
                gotoxyWithFullwidth(16, 16);
                printf("%2s%s%2s", "", modelItem[1], "");
            }
            break;
        case ' ': case 13:
            return index;
        }
    } while (1);
}

// =============================================================================
// 顯示遊戲池邊界
void printPoolBorder()
{
    int8_t y;

    SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
    for (y = ROW_BEGIN; y < ROW_END; ++y)  // 不顯示頂部4行和底部2行
    {
        gotoxyWithFullwidth(10, y - 3);
        printf("%2s", "");
        gotoxyWithFullwidth(23, y - 3);
        printf("%2s", "");
    }

    gotoxyWithFullwidth(10, y - 3);  // 底部邊界
    printf("%28s", "");
}

// 定位到遊戲池中的方格
#define gotoxyInPool(x, y) gotoxyWithFullwidth(x + 9, y - 3)

// =============================================================================
// 顯示遊戲池
void printTetrisPool(const TetrisManager *manager, const TetrisControl *control)
{
    int8_t x, y;

    for (y = ROW_BEGIN; y < ROW_END; ++y)  // 不顯示頂部4行和底部2行
    {
        gotoxyInPool(2, y);  // 定點到遊戲池中的方格
        for (x = COL_BEGIN; x < COL_END; ++x)  // 不顯示左右邊界
        {
            if ((manager->pool[y] >> x) & 1)  // 遊戲池該方格有方塊
            {
                // 用相應顏色，顯示一個實心方塊
                SetConsoleTextAttribute(g_hConsoleOutput, control->color[y][x]);
                printf("■");
            }
            else  // 沒有方塊，顯示空白
            {
                SetConsoleTextAttribute(g_hConsoleOutput, 0);
                printf("%2s", "");
            }
        }
    }
}

// =============================================================================
// 顯示當前方塊
void printCurrentTetris(const TetrisManager *manager, const TetrisControl *control)
{
    int8_t x, y;

    // 顯示當前方塊是在移動後調用的，爲擦去移動前的方塊，需要擴展顯示區域
    // 由於不可能向上移動，故不需要向下擴展
    y = (manager->y > ROW_BEGIN) ? (manager->y - 1) : ROW_BEGIN;  // 向上擴展一格
    for (; y < ROW_END && y < manager->y + 4; ++y)
    {
        x = (manager->x > COL_BEGIN) ? (manager->x - 1) : COL_BEGIN;  // 向左擴展一格
        for (; x < COL_END && x < manager->x + 5; ++x)  // 向右擴展一格
        {
            gotoxyInPool(x, y);  // 定點到遊戲池中的方格
            if ((manager->pool[y] >> x) & 1)  // 遊戲池該方格有方塊
            {
                // 用相應顏色，顯示一個實心方塊
                SetConsoleTextAttribute(g_hConsoleOutput, control->color[y][x]);
                printf("■");
            }
            else  // 沒有方塊，顯示空白
            {
                SetConsoleTextAttribute(g_hConsoleOutput, 0);
                printf("%2s", "");
            }
        }
    }
}

// =============================================================================
// 顯示下一個和下下一個方塊
void printNextTetris(const TetrisManager *manager)
{
    int8_t i;
    uint16_t tetris;

    // 邊框
    SetConsoleTextAttribute(g_hConsoleOutput, 0xF);
    gotoxyWithFullwidth(26, 1);
    printf("┏━━━━┳━━━━┓");
    gotoxyWithFullwidth(26, 2);
    printf("┃%8s┃%8s┃", "", "");
    gotoxyWithFullwidth(26, 3);
    printf("┃%8s┃%8s┃", "", "");
    gotoxyWithFullwidth(26, 4);
    printf("┃%8s┃%8s┃", "", "");
    gotoxyWithFullwidth(26, 5);
    printf("┃%8s┃%8s┃", "", "");
    gotoxyWithFullwidth(26, 6);
    printf("┗━━━━┻━━━━┛");

    // 下一個，用相應顏色顯示
    tetris = gs_uTetrisTable[manager->type[1]][manager->orientation[1]];
    SetConsoleTextAttribute(g_hConsoleOutput, manager->type[1] | 8);
    for (i = 0; i < 16; ++i)
    {
        gotoxyWithFullwidth((i & 3) + 27, (i >> 2) + 2);
        ((tetris >> i) & 1) ? printf("■") : printf("%2s", "");
    }

    // 下下一個，不顯示彩色
    tetris = gs_uTetrisTable[manager->type[2]][manager->orientation[2]];
    SetConsoleTextAttribute(g_hConsoleOutput, 8);
    for (i = 0; i < 16; ++i)
    {
        gotoxyWithFullwidth((i & 3) + 32, (i >> 2) + 2);
        ((tetris >> i) & 1) ? printf("■") : printf("%2s", "");
    }
}

// =============================================================================
// 顯示得分信息
void printScore(const TetrisManager *manager, const TetrisControl *control)
{
    static const char *modelName[] = { "遊戲模式", "觀看模式" };
    static const char *tetrisName = "ITLJZSO";
    int8_t i;

    SetConsoleTextAttribute(g_hConsoleOutput, 0xE);

    gotoxyWithFullwidth(1, 1);
    printf("■%s", control->model ? modelName[0] : modelName[1]);

    gotoxyWithFullwidth(1, 3);
    printf("□按Esc回主菜單");

    gotoxyWithFullwidth(1, 6);
    printf("■得分：%u", control->score);

    gotoxyWithFullwidth(1, 8);
    printf("■消行總數：%u", control->erasedTotal);
    for (i = 0; i < 4; ++i)
    {
        gotoxyWithFullwidth(2, 10 + i);
        printf("□消%d：%u", i + 1, control->erasedCount[i]);
    }

    gotoxyWithFullwidth(1, 15);
    printf("■方塊總數：%u", control->tetrisTotal);

    for (i = 0; i < 7; ++i)
    {
        gotoxyWithFullwidth(2, 17 + i);
        printf("□%c形：%u", tetrisName[i], control->tetrisCount[i]);
    }
}

// =============================================================================
// 顯示提示信息
void printPrompting()
{
    SetConsoleTextAttribute(g_hConsoleOutput, 0xB);
    gotoxyWithFullwidth(26, 8);
    printf("■遊戲模式：");
    gotoxyWithFullwidth(27, 10);
    printf("□向左移動：← A 4");
    gotoxyWithFullwidth(27, 11);
    printf("□向右移動：→ D 6");
    gotoxyWithFullwidth(27, 12);
    printf("□向下移動：↓ S 2");
    gotoxyWithFullwidth(27, 13);
    printf("□順時針轉：↑ W 8");
    gotoxyWithFullwidth(27, 14);
    printf("□逆時針轉：0");
    gotoxyWithFullwidth(27, 15);
    printf("□直接落地：空格");
    gotoxyWithFullwidth(27, 16);
    printf("□暫停遊戲：回車");
    gotoxyWithFullwidth(26, 18);
    printf("■觀看模式：");
    gotoxyWithFullwidth(27, 20);
    printf("□加速：↑ +");
    gotoxyWithFullwidth(27, 21);
    printf("□減速：↓ -");
    gotoxyWithFullwidth(25, 23);

    printf("■By: wohaaitinciu 13.01.01");
}

// =============================================================================
// 運行遊戲
void runGame(TetrisManager *manager, TetrisControl *control)
{
    int ch;
    clock_t clockLast, clockNow;

    clockLast = clock();  // 計時
    printTetrisPool(manager, control);  // 顯示遊戲池

    while (!control->dead)  // 沒掛
    {
        while (_kbhit())  // 有鍵按下
        {
            ch = _getch();
            if (ch == 27)  // Esc鍵
            {
                return;
            }
            keydownControl(manager, control, ch);  // 處理按鍵
        }

        if (!control->pause)  // 未暫停
        {
            clockNow = clock();  // 計時
            // 兩次記時的間隔超過0.45秒
            if (clockNow - clockLast > 0.45F * CLOCKS_PER_SEC)
            {
                clockLast = clockNow;
                keydownControl(manager, control, 80);  // 方塊往下移
            }
        }
    }
}

/*******************************************************************************

http://ielashi.com/el-tetris-an-improvement-on-pierre-dellacheries-algorithm/

改進的Pierre Dellacherie算法：（只考慮當前方塊）

一、嘗試着對當前落子的每一種旋轉變換、從左到右地擺放，產生所有擺法。

二、對每一種擺法進行評價。評價包含如下6項指標：

    1.下落高度（Landing Height）：
        當前方塊落下去之後，方塊中點距底部的方格數
        事實上，不求中點也是可以的，詳見網址

    2.消行數（Rows eliminated）
        消行層數與當前方塊貢獻出的方格數乘積

    3.行變換（Row Transitions）：
        從左到右（或者反過來）檢測一行，當該行中某個方格從有方塊到無方塊（或無方塊到有方塊），
        視爲一次變換。遊戲池邊界算作有方塊。行變換從一定程度上反映出一行的平整程度，越平整值越小
        該指標爲所有行的變換數之和
        如圖：■表示有方塊，□表示空格（遊戲池邊界未畫出）
        ■■□□■■□□■■□□ 變換數爲6
        □□□□□■□■□■□■ 變換數爲9
        ■■■■□□□□□□■■ 變換數爲2
        ■■■■■■■■■■■■ 變換數爲0

    4.列變換（Column Transitions）：大意同上
        列變換從一定程度上反映出一列中空洞的集中程度，空洞越集中值越小

    5.空洞數（Number of Holes）
        不解釋

    6.井的總和（Well Sums）：
        井指兩邊皆有方塊的空列。該指標爲所有井的深度連加到1再求總和
        注意一列中可能有多個井，如圖：
        ■□□
        ■□■
        ■□■
        ■■■
        ■□■
        ■□■
        ■□■
        中間一列爲井，深度連加到一的和爲 (2+1)+(3+2+1)=9

    各項指標權重經驗值：
    1	-4.500158825082766
    2	3.4181268101392694
    3	-3.2178882868487753
    4	-9.348695305445199
    5	-7.899265427351652
    6	-3.3855972247263626

三、比較每一種擺法的評分，取最高者。當評分相同時，比較優先度
    計算公式

        落於左側的擺法：100 * 水平平移格子數 + 10 + 旋轉次數;

        落於右側的擺法：100 * 水平平移格子數 + 旋轉次數;
*******************************************************************************/

typedef struct AIPlacing  // 擺法
{
    uint16_t action;  // 操作：高8位是旋轉次數，低8位是目標列
    uint16_t priority;  // 優先度
    int value;  // 估值
} AIPlacing;

void putDownTetris(TetrisManager *manager);  // 將方塊落到底
int calcLanding(TetrisManager *manager);  // 下落高度和消行數
int calcTrans(const TetrisManager *manager);  // 行列變換
int calcStatus(const TetrisManager *manager);  // 空洞和井
int evaluate(TetrisManager *manager);  // 估值
uint16_t getBestPlacing(const TetrisManager *manager);  // 獲取最好擺法

// =============================================================================
// 將方塊落到底
void putDownTetris(TetrisManager *manager)
{
    removeTetris(manager);  // 移走當前方塊
    for (; manager->y < ROW_END; ++manager->y)  // 從上往下
    {
        if (checkCollision(manager))  // 檢測到碰撞
        {
            break;
        }
    }
    --manager->y;  // 上移一格當然沒有碰撞
    insertTetris(manager);  // 插入當前方塊
}

// =============================================================================
// 下落高度和消行數
int calcLanding(TetrisManager *manager)
{
    int8_t x, y, k, count, cells;
    int8_t height = 25 - manager->y;  // 下落高度
    uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];

    if ((tetris & 0xF000) == 0)  // 當前方塊最上一行沒有方格
    {
        --height;
    }
    if ((tetris & 0xFF00) == 0)  // 當前方塊第二行沒有方格
    {
        --height;
    }
    if ((tetris & 0xFFF0) == 0)  // 當前方塊第三行沒有方格
    {
        --height;
    }

    cells = 0;
    count = 0;
    k = 0;
    y = manager->y + 3;  // 從下往上檢測
    do
    {
        if (y < ROW_END && manager->pool[y] == 0xFFFFU)  // 有效區域內且一行已填滿
        {
            for (x = 0; x < 4; ++x)  // 檢測當前方塊的對應行
            {
                if (((tetris >> (k << 2)) >> x) & 1)  // 這一行有方塊
                {
                    ++cells;  // 消行貢獻的方格數
                }
            }
            ++count;
            // 消除一行方塊
            memmove(manager->pool + 1, manager->pool, sizeof(uint16_t) * y);
        }
        else
        {
            --y;
            ++k;
        }
    } while (y >= manager->y && k < 4);

    height -= count;  // 再降低下落高度

    return count * cells * 34 - 45 * height;
}

// =============================================================================
// 行列變換
int calcTrans(const TetrisManager *manager)
{
    int8_t x, y;
    int rowTrans = 0, colTrans = 0;
    int filled, test;

    // 行變換
    for (y = ROW_BEGIN; y < ROW_END; ++y)  // 依次檢測各行
    {
        filled = 1;  // 遊戲池邊界算作已填充狀態
        for (x = COL_BEGIN; x < COL_END; ++x)
        {
            test = (manager->pool[y] >> x) & 1;  // 檢測格的填充狀態
            if (filled != test)  // 變換
            {
                ++rowTrans;
                filled = test;
            }
        }
        if (filled != 1)  // 遊戲池邊界
        {
            ++rowTrans;
        }
    }

    // 列變換
    for (x = COL_BEGIN ; x < COL_END; ++x)  // 依次檢測各列
    {
        filled = 1;  // 遊戲池邊界算作已填充狀態
        for (y = ROW_BEGIN; y < ROW_END; ++y)
        {
            test = (manager->pool[y] >> x) & 1;  // 檢測格的填充狀態
            if (filled != test)  // 變換
            {
                ++colTrans;
                filled = test;
            }
        }
        if (filled != 1)  // 遊戲池邊界
        {
            ++colTrans;
        }
    }

    return 32 * rowTrans + 93 * colTrans;
}

// =============================================================================
// 空洞和井
int calcStatus(const TetrisManager *manager)
{
    static const int wellDepthTable[29] =
    {
        0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66, 78,
        91, 105, 120, 136, 153, 171, 190, 210, 231, 253,
        276, 300, 325, 351, 378, 406
    };
    int8_t x, y;
    int holeCount = 0, wellDepthSum, depth;

    for (x = COL_BEGIN; x < COL_END; ++x)  // 行
    {
        for (y = ROW_BEGIN; y < ROW_END; ++y)  // 列
        {
            if ((manager->pool[y] >> x) & 1)  // 有方塊
            {
                break;
            }
        }
        while (y < 26)
        {
            if (!((manager->pool[y] >> x) & 1))  // 無方塊
            {
                ++holeCount;  // 洞的個數
            }
            ++y;
        }
    }

    wellDepthSum = 0;
    for (x = COL_BEGIN; x < COL_END; ++x)  // 列
    {
        depth = 0;
        for (y = ROW_END - 1; y >= ROW_BEGIN; --y)  // 行，從上往下
        {
            if (!((manager->pool[y] >> x) & 1))  // 無方塊
            {
                // 左右兩邊都有方塊
                if (((manager->pool[y - 1] >> x) & 1) && ((manager->pool[y + 1] >> x) & 1))
                {
                    ++depth;
                }
            }
            else
            {
                wellDepthSum += wellDepthTable[depth];
                depth = 0;
            }
        }
        wellDepthSum += wellDepthTable[depth];
    }

    return 79 * holeCount + 34 * wellDepthSum;
}

// =============================================================================
// 估值
int evaluate(TetrisManager *manager)
{
    int value = 0;

    putDownTetris(manager);  // 將方塊落到底
    value += calcLanding(manager);  // 下落高度和消行數
    value -= calcTrans(manager);  // 行列變換
    value -= calcStatus(manager);  // 空洞和井

    return value;
}

// =============================================================================
// 獲取最好擺法
uint16_t getBestPlacing(const TetrisManager *manager)
{
    int8_t i, j, count, type, ori, rotateLimit, deltaX;
    static AIPlacing placing[48];
    AIPlacing *best = NULL;
    static TetrisManager backup;

    memset(placing, 0, sizeof(AIPlacing [48]));  // 清0所有擺法

    type = manager->type[0];
    ori = manager->orientation[0];

    switch (type)  // 當前方塊類型
    {
    case TETRIS_I: case TETRIS_Z: case TETRIS_S:  // I形、Z形、S形，兩種旋轉狀態
        rotateLimit = 2;
        break;
    case TETRIS_T: case TETRIS_L: case TETRIS_J:  // T形、L形、J形，4種旋轉狀態
        rotateLimit = 4;
        break;
    case TETRIS_O:  // O形，1種旋轉狀態
        rotateLimit = 1;
        break;
    default:
        break;
    }

    // 實現未考慮下落一些格後平移來填補空洞，只計算從頂部直接落下的所有擺法
    count = 0;
    for (i = 0; i < rotateLimit; ++i)  // 嘗試各種旋轉狀態
    {
        for (j = 0; j < 13; ++j)  // 嘗試每一列
        {
            memcpy(&backup, manager, sizeof(TetrisManager));  // 遊戲數據備份
            removeTetris(&backup);  // 移除當前方塊
            backup.orientation[0] = (i + ori) & 3;  // 設置旋轉狀態
            backup.x = j;  // 設置要到達的列

            // 如果檢測到碰撞，說明方塊根本移不到那一列去
            if (!checkCollision(&backup))  // 未檢測到碰撞，得到一種擺法
            {
                placing[count].action = i;
                placing[count].action <<= 8;
                placing[count].action |= j;  // 高8位爲旋轉狀態，低8位爲要放置的列
                placing[count].value = 100000 + evaluate(&backup);  // 估值
                deltaX = j - manager->x;  // 平移的格子數 正爲右移，負爲左移
                if (deltaX > 0)  // 落於右側的擺法
                {
                    placing[count].priority = 100 * deltaX + i;  // 優先度
                }
                else  // 落於左側的擺法
                {
                    placing[count].priority = 100 * (-deltaX) + 10 + i;  // 優先度
                }
                ++count;
            }
        }
    }

    // 算法只考慮當前方塊，不遞歸
    best = placing;
    for (i = 1; i < count; ++i)
    {
        if (placing[i].value > best->value)  // 取估值最高者
        {
            best = placing + i;
        }
        else if (placing[i].value == best->value)  // 估值相同
        {
            if (placing[i].priority > best->priority)  // 取優先度高者
            {
                best = placing + i;
            }
        }
    }

    return best->action;  // 返回擺法
}

// =============================================================================
// 自動運行
void autoRun(TetrisManager *manager, TetrisControl *control)
{
    uint16_t best;
    int8_t i, rotate, destX, deltaX;
    DWORD delayTime = 100;
    int ch;

    printTetrisPool(manager, control);  // 顯示遊戲池

    while (!control->dead)  // 沒掛
    {
        while (_kbhit())  // 處理按鍵
        {
            ch = _getch();
            switch (ch)
            {
            case 27: // Esc鍵
                return;
            case 13:  // 回車鍵
                control->pause = !control->pause;  // 切換暫停狀態
                break;
            case 72: case '+': // 上
                if (delayTime > 0)
                {
                    delayTime -= 5;
                }
                break;
            case 80: case '-':  // 下
                if (delayTime < 200)
                {
                    delayTime += 5;
                }
                break;
            }
        }

        if (control->pause)  // 暫停狀態
        {
            continue;
        }

        for (i = 0; i < 3; ++i)  // 將給的方塊下移3格，方便觀察
        {
            keydownControl(manager, control, 's');
        }

        best = getBestPlacing(manager);  // 獲取最好擺法
        rotate = (best >> 8);  // 高8位是旋轉次數
        destX = (best & 0x0F);  // 低8位是目標列
        deltaX = destX - manager->x;  // 移動的格數，結果爲正向右移，負向左移

        for (i = 0; i < rotate; ++i)  // 旋轉
        {
            keydownControl(manager, control, 'w');
            Sleep(delayTime);
        }

        if (deltaX > 0)
        {
            for (i = 0; i < deltaX; ++i)  // 向右移
            {
                keydownControl(manager, control, 'd');
                Sleep(delayTime);
            }
        }
        else if (deltaX < 0)
        {
            for (i = 0; i < -deltaX; ++i)  // 向左移
            {
                keydownControl(manager, control, 'a');
                Sleep(delayTime);
            }
        }

        keydownControl(manager, control, ' ');  // 移動好後，直接落地
    }
}