俄罗斯方块源码（彩色版）

此程序使用C语言简单实现了俄罗瑟方块主要的游戏功能（包含统计得分、速度等级设置、下一方块提示），还有简单的消除特效。

使用的编译器为：Visual Studio 2022

效果图：

 

 

主要缺点：

1：代码较长

2：注释写的不是很详细

3：屏幕闪烁问题

#include<stdio.h>
#include <iostream>
#include <Windows.h>
#include <conio.h>
#include <time.h>

//用数组表示俄罗斯方块的所有情况
int SQUARES[7][4] = { {1, 1, 1, 1}, {1, 2, 3, 4}, {1, 2, 3, 4}, {1, 2, 1, 2}, {1, 2, 1, 2}, {1, 2, 1, 2}, {1, 2, 3, 4} };

橘色区域为方块的重心 

clock_t start, now;             //用于控制方块定时下落，start：当前方块上一次下落开始时刻，now：当前时刻
int Score = 0;                  //统计得分
int Speed = 0;                  //方块下落速度
int High = 23;                  //当前已堆积的方块的最高行行序号
int Line = 4;                   //代表当前方块所在行
int Col = 17;                   //代表当前方块所在列
int I = 1;                      //当前方块
int J = 0;                      //控制方块旋转参数
int Color = 3;                  //控制方块颜色
int NEXT = 0;                   //下一个方块
int Flag = 1;                   //新游戏开始标志
int INTERFACE[26][29] = {0};    //将游戏区分为26*29的表，利用“0”“非零”进行游戏区的显示

 函数声明：

void Screen_Refresh();                          //屏幕刷新，显示当前游戏状态
void Print_Square(int, int, int, int, int);     //打印对应方块函，i,j:方块类型及对应形态  L,C:方块位置  color:方块颜色
void Framework_interface();                     //生成界面框架
void Show_Game_Area();                          //显示游戏区
void Move_Whirl();                              //控制方块移动、旋转
void Rand_Block();                              //随机生成方块函数（当前方块、下一个方块、方块颜色）
void Next_Square();                             //下一个方块提示
int L_Move_Judge(int, int);                     //判断方块是否能进行向左移动
int R_Move_Judge(int, int);                     //判断方块是否能进行向右移动
int Down_Judge(int, int);                       //判断方块是否能进行向下移动
int Whirl_Judge(int, int);                      //判断方块是否能进行旋转
void Line_High();                               //返回当前已堆积方块的最高行行序号，在ELiminate_Judge()及中Game_over_Judge()被用到
int Eliminate_Judge();                          //消除判断及消除
void Statistical_Score(int);                    //计分函数,所需参数为消除行数，与Eliminate_Judge()函数配合使用
void Speed_Judge();                             //速度等级判断
void Game_over_Judge();                         //游戏结束判断

 主函数：

int main() {
    int i = I, j = J;
    Framework_interface(); //设置界面框架
    while (1) {
        Line = 3;           //方块初始下落行
        Col = 17;           //方块初始下路列
        Rand_Block();       //随机生成方块及方块颜色
        Next_Square();      //在对应的框内显示下一个方块
        while (1) {
            start = clock();    //当前方块开始下落时间
            now = start;        //now初始化为start，以便安全进入 while ((now - start) <= 2000 - Speed * 200) 循环
            Screen_Refresh();   //刷新屏幕，显示当前状态
            while ((now - start) <= 2000 - Speed * 200) {       //控制方块定时下落
                Move_Whirl();       //控制方块移动、旋转
                now = clock();      //记录当前时间
            }
            if (Down_Judge(I, J)) {     //判断方块是否能继续下落
                Line++;                 //方块下落一行
                Screen_Refresh();       //刷新屏幕，显示当前状态
            }
            else {                      //方块已经落地
                Print_Square(I, J, Line, Col, Color);   //将方块固定在当前位置
                Statistical_Score(Eliminate_Judge());   //判断是否满足消除条件，统计得分
                Game_over_Judge();                      //判断游戏是否结束
                break;                                  //如游戏未结束，则跳出当前循环，继续生成下一个方块

            }
        }
    }
    return 0;
}

 各函数内容：

//打印对应方块函，i,j:方块类型及对应形态  L,C:方块位置  color:方块颜色

void Print_Square(int i, int j, int L, int C, int color) { //i、j用来确定要打印的方块的类型(i:方块、j:旋转)
    int col = 14;
    switch (i) {
    case 0: 
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            INTERFACE[L + 1][C] = color;
            INTERFACE[L + 1][C + 1] = color;
        break;
    case 1:
        switch (SQUARES[i][j]) {
        case 1: 
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            INTERFACE[L + 1][C - 1] = color;
            break;
        case 2:
            INTERFACE[L - 1][C - 1] = color;
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            break;
        case 3:
            INTERFACE[L - 1][C + 1] = color;
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            break;
        case 4:
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            INTERFACE[L + 1][C + 1] = color;
            break;
        }
        break;
    case 2:
        switch (SQUARES[i][j]) {
        case 1:
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            INTERFACE[L + 1][C] = color;
            break;
        case 2:
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            break;
        case 3:
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            break;
        case 4:
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            INTERFACE[L + 1][C] = color;
            break;
        }
        break;
    case 3:
        switch (SQUARES[i][j]) {
        case 1:
            INTERFACE[L][C - 2] = color;
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            break;
        case 2:
            INTERFACE[L - 2][C] = color;
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            break;
        }
        break;
    case 4:
        switch (SQUARES[i][j]) {
        case 1: 

            INTERFACE[L - 1][C - 1] = color;
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            break;
        case 2:
            INTERFACE[L - 1][C + 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            INTERFACE[L + 1][C] = color;
            break;
        }
        break;
    case 5:
        switch (SQUARES[i][j]) {
        case 1:
            INTERFACE[L - 1][C] = color;
            INTERFACE[L - 1][C + 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C - 1] = color;
            break;
        case 2:
            INTERFACE[L - 1][C - 1] = color;
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            break;
        }
        break;
    case 6:
        switch (SQUARES[i][j]) {
        case 1:
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            INTERFACE[L + 1][C + 1] = color;
            break;
        case 2:
            INTERFACE[L - 1][C] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            INTERFACE[L + 1][C - 1] = color;
            break;
        case 3:
            INTERFACE[L - 1][C - 1] = color;
            INTERFACE[L][C - 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L][C + 1] = color;
            break;
        case 4: 
            INTERFACE[L - 1][C] = color;
            INTERFACE[L - 1][C + 1] = color;
            INTERFACE[L][C] = color;
            INTERFACE[L + 1][C] = color;
            break;
        }
        break;
    }
    if(L <= 5)
        for (col == 14; col < 26; col++)
        INTERFACE[2][col] = 1;
}

//生成界面框架
void Framework_interface() {
    int T_coord[4] = { 0, 0, 25, 28 };    //总框左上角、右下角两个顶点（坐标确定一个长方形）
    int S_coord[4] = { 2, 2, 6, 11 };    //得分框左上角、右下角两个顶点
    int SP_coord[4] = { 8, 2, 12, 11 };   //下落速度框左上角、右下角两个顶点
    int N_coord[4] = { 14, 2, 22, 11 };    //下一方块提示左上角、右下角两个框顶点
    int G_coord[4] = { 2, 13, 23, 26 };    //游戏区左上角、右下角两个顶点
    int i, j;
    for (i = T_coord[0], j = T_coord[1]; j <= T_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = T_coord[2], j = T_coord[1]; j <= T_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = T_coord[0], j = T_coord[1]; i <= T_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = T_coord[0], j = T_coord[3]; i <= T_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = S_coord[0], j = S_coord[1]; j <= S_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = S_coord[2], j = S_coord[1]; j <= S_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = S_coord[0], j = S_coord[1]; i <= S_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = S_coord[0], j = S_coord[3]; i <= S_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = SP_coord[0], j = SP_coord[1]; j <= SP_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = SP_coord[2], j = SP_coord[1]; j <= SP_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = SP_coord[0], j = SP_coord[1]; i <= SP_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = SP_coord[0], j = SP_coord[3]; i <= SP_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = N_coord[0], j = N_coord[1]; j <= N_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = N_coord[2], j = N_coord[1]; j <= N_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = N_coord[0], j = N_coord[1]; i <= N_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = N_coord[0], j = N_coord[3]; i <= N_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = G_coord[0], j = G_coord[1]; j <= G_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = G_coord[2], j = G_coord[1]; j <= G_coord[3]; j++)
        INTERFACE[i][j] = 1;
    for (i = G_coord[0], j = G_coord[1]; i <= G_coord[2]; i++)
        INTERFACE[i][j] = 1;
    for (i = G_coord[0], j = G_coord[3]; i <= G_coord[2]; i++)
        INTERFACE[i][j] = 1;
}
//显示游戏区
void Show_Game_Area() {
    int i = 0, j = 0;
    for (i = 0; i < 26; i++) {
        for (j = 0; j < 29; j++) {
            if (i == 3 && j == 4) {
                printf("\033[40mS C O R E:\033[0m");
                j = j + 5;
            }
            else if (i == 4 && j == 4) {
                printf("\033[40m% 9d \033[0m", Score);
                j = j + 5;
            }
            else if (i == 9 && j == 4) {
                printf("\033[40mS P E E D:\033[0m");
                j = j + 5;
            }
            else if (i == 10 && j ==4) {
                printf("\033[40m% 9d \033[0m", Speed + 1);
                j = j + 5;
            }
            else if (i == 15 && j == 4) {
                printf("\033[40m N E X T: \033[0m");
                j = j + 5;
            }
            switch (INTERFACE[i][j]) {
            case 0:
                printf("\033[40m  \033[0m");
                break;
            case 1:
                printf("\033[46m■\033[0m");
                break;
            case 2:
                printf("\033[41m■\033[0m");
                break;
            case 3:
                printf("\033[42m■\033[0m");
                break;
            case 4:
                printf("\033[43m■\033[0m");
                break;
            case 5:
                printf("\033[44m■\033[0m");
                break;
            case 6:
                printf("\033[45m■\033[0m");
                break;
            case 9:
                printf("\033[40m■\033[0m");
                break;
            case 10:
                printf("\033[46m■\033[0m");
                break;
            }
        }
            

            
        putchar('\n');
    }
} 
//控制方块移动、旋转
void Move_Whirl() {               //左、右移移动，加速下落
    int i = 0;
    char input;
    if (_kbhit())
    {
        input = _getch();
        if (input == 'a')
            if(L_Move_Judge(I, J))
                Col--;
        if (input == 'd')
            if(R_Move_Judge(I, J))
                Col++;
        if (input == 's')
            for (i = 0; i < 3; i++)
                if (Down_Judge(I, J))
                    Line++;
                else
                    break;
        if (input == 'w')
            if(Whirl_Judge(I, J))
              J = (J + 1) % 4;
        Screen_Refresh();
    }
}
//随机生成方块函数（当前方块、下一个方块）
void Rand_Block() {
    int a;
    if (Flag == 1) {
        Flag = 0;
        srand(time(0));
        Color = rand() % 5 + 2;
        I = rand() % 7;
        NEXT = rand() % 7;
    }
    else {
        Color = rand() % 5 + 2;
        I = NEXT;
        NEXT = rand() % 7;
    }
}

//判断方块是否能进行向左、向右、向下移动、旋转
int L_Move_Judge(int i, int j) {
    int L = Line, C = Col;
    switch (i) {
    case 0:
        if (INTERFACE[L][C - 1])
            return 0;
        if (INTERFACE[L + 1][C - 1])
            return 0;
        break;
    case 1:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C - 2])
                return 0;
            if (INTERFACE[L + 1][C - 2])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C - 2])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L][C - 2])
                return 0;
            break;
        case 4:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    case 2:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C - 2])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 2])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 2])
                return 0;
            break;
        case 4:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    case 3:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C - 3])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 2][C - 1])
                return 0;
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    case 4:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C - 2])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    case 5:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 2])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C -2])
                return 0;
            if (INTERFACE[L][C - 2])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    case 6:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C - 2])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 2])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C - 2])
                return 0;
            if (INTERFACE[L][C - 2])
                return 0;
            break;
        case 4:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    }
    return 1;
}
int R_Move_Judge(int i, int j) {
    int L = Line, C = Col;
    switch (i) {
    case 0:
        if (INTERFACE[L][C + 2])
            return 0;
        if (INTERFACE[L + 1][C + 2])
            return 0;
        break;
    case 1:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C + 2])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C + 2])
                return 0;
            if (INTERFACE[L][C + 2])
                return 0;
            break;
        case 4:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 2])
                return 0;
            break;
        }
        break;
    case 2:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C + 2])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 2])
                return 0;
            break;
        case 4:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 2])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    case 3:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C + 2])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 2][C + 1])
                return 0;
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    case 4:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 2])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C + 2])
                return 0;
            if (INTERFACE[L][C + 2])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    case 5:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C + 2])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    case 6:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C + 2])
                return 0;
            if (INTERFACE[L + 1][C + 2])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L][C + 2])
                return 0;
            break;
        case 4:
            if (INTERFACE[L - 1][C + 2])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    }
    return 1;
}
int Down_Judge(int i, int j) {
    int L = Line, C = Col;
    switch (i) {
    case 0:
        if (INTERFACE[L + 2][C])
            return 0;
        if (INTERFACE[L + 2][C + 1])
            return 0;
        break;
    case 1:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            if (INTERFACE[L + 2][C - 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L + 2][C])
                return 0;
            break;
        case 3:
            if (INTERFACE[L + 1][C + 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        case 4:
            if (INTERFACE[L + 2][C])
                return 0;
            if (INTERFACE[L + 2][C + 1])
                return 0;
            break;
        }
        break;
    case 2:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 2][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L + 2][C])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 4:
            if (INTERFACE[L + 2][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    case 3:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L + 1][C - 2])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L + 2][C])
                return 0;
            break;
        }
        break;
    case 4:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L][C + -1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L + 2][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        }
        break;
    case 5:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 2][C])
                return 0;
            break;
        }
        break;
    case 6:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 2][C + 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L + 2][C - 1])
                return 0;
            if (INTERFACE[L + 2][C])
                return 0;
            break;
        case 3:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            break;
        case 4:
            if (INTERFACE[L + 2][C])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            break;
        }
        break;
    }
    return 1;

}
int Whirl_Judge(int i, int j) {
    int L = Line, C = Col;
    switch (i) {
    case 0:
        break;
    case 1:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C + 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L + 1][C + 1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L - 1][C])
                return 0;
            break;
        case 4:
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        }
        break;
    case 2:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L][C + 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L - 1][C])
                return 0;
            break;
        case 4:
            if (INTERFACE[L][C - 1])
                return 0;
            break;
        }
        break;
    case 3:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 2][C])
                return 0;
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L][C - 2])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            break;
        }
        break;
    case 4:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C +1])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L - 1][C])
                return 0;
            break;
        }
        break;
    case 5:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L + 1][C - 1])
                return 0;
            if (INTERFACE[L - 1][C])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L - 1][C + 1])
                return 0;
            break;
        }
        break;
    case 6:
        switch (SQUARES[i][j]) {
        case 1:
            if (INTERFACE[L - 1][C])
                return 0;
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C - 1])
                return 0;
            break;
        case 2:
            if (INTERFACE[L - 1][C - 1])
                return 0;
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            break;
        case 3:
            if (INTERFACE[L + 1][C])
                return 0;
            if (INTERFACE[L + 1][C + 1])
                return 0;
            if (INTERFACE[L - 1][C])
                return 0;
            break;
        case 4:
            if (INTERFACE[L][C - 1])
                return 0;
            if (INTERFACE[L][C + 1])
                return 0;
            if (INTERFACE[L - 1][C + 1])
                return 0;
            break;
        }
        break;
    }
    return 1;
}

//返回当前已堆积方块的最高行行序号，在ELiminate_Judge()中被用到
void Line_High() {
    int l, c, h = 23; 
    for (c = 14; c < 26; c++) {
        for (l = 3; INTERFACE[l][c] == 0; l++);
        if (l < h)
            h = l;
    }
    High = h;

}
//消除判断及消除
int Eliminate_Judge() {
    int i, j;
    int m = 0, n = 0;           //m：空行 n：非空行
    int Eline_num = 0;  //统计消除行数
    int Eflag[4] = { 0 };      //消除标志，值为0：代表不满足消除条件 值大于0：代表满足消除条件的行序号
    int Eline = 0;      //当前所判断的行序号
    int Ecol = 0;       //当前所判断的列序号
    for (Eline = Line + 1; Eline >= Line - 2; Eline--) {      //判断当前重心上下共4行（Line-2 ~ Line+1），是否满足消除条件
        if (Eline >= 23) {
            Eflag[3] = 0;
            Eline--;
        }
        for (Ecol = 14; Ecol < 26; Ecol++)
            if (INTERFACE[Eline][Ecol] == 0)
                break;
        if (Ecol == 26) {
            Eflag[Eline - Line + 2] = Eline;
            Eline_num++;
        }
        else
            Eflag[Eline - Line + 2] = 0;
    }
    if (Eline_num != 0) {
        for (i = 0; i < 4; i++) {      //消除效果①：改变所有满足消除条件的行的显示效果
            if (Eflag[i] != 0)
                for (Ecol = 14, Eline = Eflag[i]; Ecol < 26; Ecol++)
                    INTERFACE[Eline][Ecol] = 10;
        }
        system("cls");
        Show_Game_Area();
        Sleep(100);
        for (i = 0; i < 4; i++) {      //消除效果②：将要消除的行置为空
            if (Eflag[i] != 0)
                for (Ecol = 14; Ecol < 26; Ecol++)
                    INTERFACE[Eflag[i]][Ecol] = 0;
        }
        system("cls");
        Show_Game_Area();
        Sleep(100);
        Line_High();                           //获取行高
        i = 3;                                 //消除效果③：将被消除的行上方的方块，向下平移
        if (i >= 0) { 
            while (Eflag[i] == 0)
                i--;
            m = Eflag[i];
            j = i - 1;
        }
        for (n = m - 1; n >= High - 1 && n > 2; m--, n--) { 
            while (Eflag[j] != 0 && j >= 0) {
                n--;
                j--;
            }
            
            for (Ecol = 14; Ecol < 26; Ecol++) {
                INTERFACE[m][Ecol] = INTERFACE[n][Ecol];
                INTERFACE[n][Ecol] = 0;
            }
        }
        system("cls");
        Show_Game_Area();
        Sleep(10);
    }
    return Eline_num;
}
//计分函数,所需参数为消除行数，与Eliminate_Judge()函数配合使用
void Statistical_Score(int num) {
    switch (num) {
    case 0:
        break;
    case 1:
        Score += 10;
        Speed_Judge();
        break;
    case 2:
        Score += 30;
        Speed_Judge();
        break;
    case 3:
        Score += 60;
        Speed_Judge();
        break;
    case 4:
        Score += 100;
        Speed_Judge();
        break;
    }
}
//下一个方块提示
void Next_Square() {
    int i, j;
    if (INTERFACE[19][6] != 0)
        for (i = 17; i <= 21; i++)
            for (j = 4; j <= 8; j++)
                INTERFACE[i][j] = 0;
    Print_Square(NEXT, 2, 19, 6, 9);
}
//速度等级判断
void Speed_Judge() {
    Speed = (int)(Score / 1000);
}
//屏幕刷新，显示当前游戏状态
void Screen_Refresh() {
    Print_Square(I, J, Line, Col, Color);
    system("cls");
    Show_Game_Area();
    Print_Square(I, J, Line, Col, 0);
}
//游戏结束判断
void Game_over_Judge() {
    Line_High();
    if (High == 3) {
        system("cls");
        printf("\t\t\tGAME OVER!");
        exit(0);
    }
}

 本人小白，初来乍到，还请各位大佬多多指点~

如有问题和建议欢迎评论，感谢