C語言俄羅斯方塊

#include <windows.h>
#include <stdio.h>
#include <time.h>
#include <conio.h>
#include <stdlib.h>
char gcText[] = " 1LJTSZ#";
struct tetris {
    int _pool[16][32], (*pool)[32], tmap[8][4][16];
    int x, y, s, st, t;
}gt;

void trsInit() {
    int sp[8][4] = {{15,4369},{23,785,116,547},{71,275,113,802},
        {39,305,114,562},{54,561},{99,306},{51,51},{-1}};
    int *p, i, j, b;
    for (p = sp[0]; *p >= 0; ++p) if ( *p == 0 ) *p = p[-2];
    gt.pool = &gt._pool[4];
    for (j = 0; j < 7; ++j)
        for (i = 0; i < 4; ++i)
            for (b = 0; b < 16; ++b)
                gt.tmap[j+1][i][b] = (sp[j][i] & 1) * (j + 1),
                sp[j][i] >>= 1;
    memset(gt._pool, -1, sizeof(gt._pool));
    for (i = 0; i < 10; ++i)
        memset(&gt.pool[i], 0, sizeof(int[21]));
    return ;
}

int trsCopy(int sp[], int x, int y, int c) {
    int i, cx, cy;
    for (i = 0; i < 16; ++i) if (sp[i]) {
        cx = x + (i & 3), cy = y + (i >> 2);
        if (gt.pool[cx][cy])
            {
                if (c == 2)
                gt.pool[cx][cy] = 0;
            else
                return 0;
            }

        if (c==1) gt.pool[cx][cy] = sp[i];
    }
    return 1;
}

int trsScene() {
    int x, y = 0;
    COORD pos = {0};
    gt.s = rand() % 7 + 1, gt.st = gt.t = 0;
    gt.x = 3, gt.y = 0;
    for (--gt.t; ; Sleep(1), --gt.t) {
        int k = 0;
        while (kbhit()) {
            k = getch();
            if (k == 27) return 0;
            if (k == 'A' || k == 'a') {
                if (trsCopy(gt.tmap[gt.s][gt.st], gt.x-1, gt.y, 0)) --gt.x;
            } else if (k == 'D' || k == 'd') {
                if (trsCopy(gt.tmap[gt.s][gt.st], gt.x+1, gt.y, 0)) ++gt.x;
            } else if (k == 'W' || k == 'w') {
                if (trsCopy(gt.tmap[gt.s][(gt.st+1) % 4], gt.x, gt.y, 0))
                    gt.st = (gt.st+1) % 4;
            }
        }
        if (k == 'S' || k == 's' || gt.t < 0) {
            if (trsCopy(gt.tmap[gt.s][gt.st], gt.x, gt.y+1, 0))++gt.y,gt.t=50;
            else {
                trsCopy(gt.tmap[gt.s][gt.st], gt.x, gt.y, 1);
                for (--y; y > 0; --y) {
                    for (x = 0; gt.pool[x][y] > 0; ++x);
                    if (gt.pool[x][y] < 0)
                        for (k = y++; k > 0; --k)
                            for (x = 0; gt.pool[x][0] >= 0; ++x)
                                gt.pool[x][k] = gt.pool[x][k-1];
                }
                return 1;
            }
        }
        trsCopy(gt.tmap[gt.s][gt.st], gt.x, gt.y, 1);
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
        for (y = 1; gt.pool[0][y] >= 0; ++y,putchar(10)) {
            for (x = 0; gt.pool[x][0] >= 0; ++x) {
                putchar(gcText[gt.pool[x][y]]);
            }
        }
        trsCopy(gt.tmap[gt.s][gt.st], gt.x, gt.y, 2);
    }
}

int main() {
    srand((unsigned)time(NULL));
    for (trsInit(); trsScene(); );
    return 0;
}

 精美版

#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

// =============================================================================
// 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，便於進行碰撞檢測
// 這樣一來遊戲池的寬度爲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];  // 當前、下一個和下下一個方塊旋轉狀態
    unsigned score;  // 得分
    unsigned erasedCount[4];  // 消行數
    unsigned erasedTotal;  // 消行總數
    unsigned tetrisCount[7];  // 各方塊數
    unsigned tetrisTotal;  // 方塊總數
    bool dead;  // 掛
} TetrisManager;

// =============================================================================
typedef struct TetrisControl  // 這個結構體存儲控制相關數據
{
    bool pause;  // 暫停
    bool clockwise;  // 旋轉方向：順時針爲true
    int8_t direction;  // 移動方向：0向左移動 1向右移動
    // 遊戲池內每格的顏色
    // 因爲此版本是彩色的，僅用遊戲池數據沒法存儲顏色信息
    // 固然，若是隻實現單色版的，就不必用這個數組了
    int8_t color[28][16];
} TetrisControl;

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

// =============================================================================
// 函數聲明
// 若是使用全局變量方式實現，就不必傳參了
void initGame(TetrisManager *manager, TetrisControl *control);  // 初始化遊戲
void restartGame(TetrisManager *manager, TetrisControl *control);  // 從新開始遊戲
void giveTetris(TetrisManager *manager);  // 給一個方塊
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);  // 顯示得分信息
void runGame(TetrisManager *manager, TetrisControl *control);  // 運行遊戲
void printPrompting();  // 顯示提示信息
bool ifPlayAgain();  // 再來一次

// =============================================================================
// 出處：http://www.oschina.net/code/snippet_255612_16922
// 主函數
int main() {
    TetrisManager tetrisManager;
    TetrisControl tetrisControl;

    initGame(&tetrisManager, &tetrisControl);  // 初始化遊戲
    do {
        printPrompting();  // 顯示提示信息
        printPoolBorder();  // 顯示遊戲池邊界
        runGame(&tetrisManager, &tetrisControl);  // 運行遊戲
        if (ifPlayAgain())  // 再來一次
        {
            SetConsoleTextAttribute(g_hConsoleOutput, 0x7);
            system("cls");  // 清屏
            restartGame(&tetrisManager, &tetrisControl);  // 從新開始遊戲
        } else {
            break;
        }
    } while (1);
    gotoxyWithFullwidth(0, 0);
    CloseHandle(g_hConsoleOutput);
    return 0;
}

// =============================================================================
// 初始化遊戲
void initGame(TetrisManager *manager, TetrisControl *control) {
    CONSOLE_CURSOR_INFO cursorInfo = { 1, FALSE };  // 光標信息

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

    restartGame(manager, control);
}

// =============================================================================
// 從新開始遊戲
void restartGame(TetrisManager *manager, TetrisControl *control) {
    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

    giveTetris(manager);  // 給下一個方塊
    setPoolColor(manager, control);  // 設置顏色
}

// =============================================================================
// 給一個方塊
void giveTetris(TetrisManager *manager) {
    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))  // 檢測到碰撞
            {
        manager->dead = true;  // 標記遊戲結束
    } else  // 未檢測到碰撞
    {
        insertTetris(manager);  // 將當前方塊加入遊戲池
    }

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

    printNextTetris(manager);  // 顯示下一個方塊
    printScore(manager);  // 顯示得分信息
}

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

    // 獲取當前方塊在遊戲池中的區域：
    // 遊戲池座標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);  // 移走當前方塊
    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);

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

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

    giveTetris(manager);  // 給下一個方塊
    setPoolColor(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);
}

// =============================================================================
// 顯示遊戲池邊界
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) {
    static const char *tetrisName = "ITLJZSO";
    int8_t i;

    SetConsoleTextAttribute(g_hConsoleOutput, 0xE);

    gotoxyWithFullwidth(2, 2);
    printf("■得分：%u", manager->score);

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

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

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

// =============================================================================
// 顯示提示信息
void printPrompting() {
    SetConsoleTextAttribute(g_hConsoleOutput, 0xB);
    gotoxyWithFullwidth(26, 10);
    printf("■控制：");
    gotoxyWithFullwidth(27, 12);
    printf("□向左移動：← A 4");
    gotoxyWithFullwidth(27, 13);
    printf("□向右移動：→ D 6");
    gotoxyWithFullwidth(27, 14);
    printf("□向下移動：↓ S 2");
    gotoxyWithFullwidth(27, 15);
    printf("□順時針轉：↑ W 8");
    gotoxyWithFullwidth(27, 16);
    printf("□逆時針轉：0");
    gotoxyWithFullwidth(27, 17);
    printf("□直接落地：空格");
    gotoxyWithFullwidth(27, 18);
    printf("□暫停遊戲：回車");
    gotoxyWithFullwidth(25, 23);
    printf("■By: wohaaitinciu 12.12.29");
}

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

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

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

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

// =============================================================================
// 再來一次
bool ifPlayAgain() {
    int ch;

    SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
    gotoxyWithFullwidth(15, 10);
    printf("遊戲結束");
    gotoxyWithFullwidth(13, 11);
    printf("按Y重玩，按N退出");

    do {
        ch = _getch();
        if (ch == 'Y' || ch == 'y') {
            return true;
        } else if (ch == 'N' || ch == 'n') {
            return false;
        }
    } while (1);
}