俄罗斯方块游戏（C语言）

简介：俄罗斯方块（Tetris）是一款经典的游戏，下面是用C语言实现俄罗斯方块的示例代码：

code

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

#define HEIGHT 20  // 方块区域高度
#define WIDTH 10   // 方块区域宽度
#define SIZE 4     // 方块大小

int score = 0;     // 得分
int map[HEIGHT][WIDTH];  // 地图

// 定义方块结构体
typedef struct {
    int x[SIZE];
    int y[SIZE];
    int type;
} Block;

// 方块类型数组
Block blocks[] = {
    {0, 0, 1, 0, 1, 1, 2, 1},    // T
    {0, 0, 0, 1, 0, 2, 0, 3},    // I
    {0, 0, 1, 0, 1, 1, 2, 1},    // Z
    {0, 1, 1, 1, 1, 0, 2, 0},    // S
    {0, 0, 0, 1, 1, 0, 1, 1},    // O
    {0, 1, 1, 1, 2, 1, 2, 0},    // L
    {0, 0, 1, 0, 2, 0, 2, 1}     // J
};

// 随机生成方块
Block randomBlock() {
    Block block;
    int type = rand() % 7;
    block.type = type;
    for (int i = 0; i < SIZE; i++) {
        block.x[i] = blocks[type].x[i];
        block.y[i] = blocks[type].y[i];
    }
    return block;
}

// 判断方块是否超出边界
int isOut(int x, int y) {
    if (x < 0 || x >= HEIGHT || y < 0 || y >= WIDTH) {
        return 1;
    }
    return 0;
}

// 判断方块是否和地图上的方块重叠
int isOverlap(int x, int y) {
    if (map[x][y]) {
        return 1;
    }
    return 0;
}

// 检测方块是否可以移动
int canMove(Block block, int dx, int dy) {
    for (int i = 0; i < SIZE; i++) {
        int x = block.x[i] + dx;
        int y = block.y[i] + dy;
        if (isOut(x, y) || isOverlap(x, y)) {
            return 0;
        }
    }
    return 1;
}

// 绘制方块
void drawBlock(Block block, int value) {
    for (int i = 0; i < SIZE; i++) {
        int x = block.x[i];
        int y = block.y[i];
        map[x][y] = value;
    }
}

// 消除满行
void clearLine() {
    int count = 0;
    for (int i = HEIGHT - 1; i >= 0; i--) {
    int flag = 1;
    for (int j = 0; j < WIDTH; j++) {
        if (!map[i][j]) {
            flag = 0;
            break;
        }
    }
    if (flag) {
        count++;
        for (int j = 0; j < WIDTH; j++) {
            for (int k = i; k > 0; k--) {
                map[k][j] = map[k - 1][j];
            }
            map[0][j] = 0;
        }
        i++;
        score += 100;
    }
}
if (count) {
    printf("Score: %dn", score);
}
}

// 绘制地图
void drawMap() {
system("cls");
for (int i = 0; i < HEIGHT; i++) {
for (int j = 0; j < WIDTH; j++) {
if (map[i][j]) {
printf("■ ");
} else {
printf("□ ");
}
}
printf("n");
}
printf("Score: %dn", score);
}

// 游戏结束
void gameOver() {
printf("Game Over!n");
printf("Score: %dn", score);
exit(0);
}

// 主函数
int main() {
srand((unsigned)time(NULL)); // 随机数种子
Block block = randomBlock(); // 随机生成方块
while (1) {
drawMap(); // 绘制地图
if (!canMove(block, 1, 0)) {
drawBlock(block, 1); // 将方块放到地图上
clearLine(); // 消除满行
block = randomBlock(); // 随机生成方块
if (!canMove(block, 0, 0)) {
gameOver(); // 游戏结束
}
}
if (_kbhit()) { // 监听键盘输入
int key = _getch();
switch (key) {
case 'w': // 旋转
{
Block temp = block;
for (int i = 0; i < SIZE; i++) {
int x = block.x[i];
int y = block.y[i];
temp.x[i] = block.x[0] + block.y[0] - y;
temp.y[i] = block.y[0] - block.x[0] + x;
}
if (canMove(temp, 0, 0)) {
block = temp;
}
break;
}
case 'a': // 左移
if (canMove(block, 0, -1)) {
for (int i = 0; i < SIZE; i++) {
block.y[i]--;
}
}
break;
case 's': // 下移
if (canMove(block, 1, 0)) {
for (int i = 0; i < SIZE; i++) {
block.x[i]++;
}
}
break;
case 'd': // 右移
if (canMove(block, 0, 1)) {
for (int i = 0; i < SIZE; i++) {
block.y[i]++;
}
}
break;
case ' ': // 直接下落到底部
while (canMove(block, 1, 0)) {
for (int i = 0; i < SIZE; i++) {
block.x[i]++;
}
}
drawBlock(block, 1); // 将方块放到地图上
clearLine(); // 消除满行
block = randomBlock(); // 随机生成方块
if (!canMove(block, 0, 0)) {
gameOver(); // 游戏结束
}
break;
}
}
Sleep(200); // 速度控制
if (canMove(block, 1, 0)) { // 向下移动
for (int i = 0; i < SIZE; i++) {
block.x[i]++;
}
}
}
return 0;
}

这是一个非常简单的俄罗斯方块游戏，只有基本的方块形状和控制操作。如果想要更加完整的游戏体验，可以添加更多的方块形状、音效、背景音乐、计分系统等等。

分析

这份代码是一个简单的俄罗斯方块游戏实现，其中包含以下功能：

initMap()：初始化地图。将所有的方格都设为0，即空格。
randomBlock()：随机生成一个方块。包含了7种基本方块形状，每种形状都有4个旋转状态。
canMove(block, dx, dy)：判断方块是否可以向某个方向移动。其中，dx表示x轴的移动距离，dy表示y轴的移动距离。
drawBlock(block, val)：将方块放到地图上。val为1表示将方块填充到地图上，为0表示将方块从地图上移除。
clearLine()：消除满行。如果某一行所有方格都被填充，就将该行清除，并且分数加100。
drawMap()：绘制地图。将地图上的方块打印出来，用"□"表示空格，用"■"表示填充的方块。
gameOver()：游戏结束。打印出游戏结束信息和分数，并结束游戏。
main()：主函数。包含了游戏循环，监听键盘输入，并控制方块的移动和旋转。同时，每隔一段时间会将方块向下移动，如果方块无法继续向下移动，就将方块放到地图上，检查是否有满行，随机生成下一个方块，如果无法继续生成，就结束游戏。
这份代码实现了一个基本的俄罗斯方块游戏，如果想要增加更多功能，可以在此基础上进行扩展。

详细分析

面我会详细分析一下这份代码的实现过程。
首先，在代码的开头，我们看到了一些宏定义和结构体定义：
#define WIDTH 10 // 地图宽度
#define HEIGHT 20 // 地图高度
#define SIZE 4 // 方块大小

struct Block {
int x[SIZE]; // 方块的x坐标
int y[SIZE]; // 方块的y坐标
int type; // 方块类型
int dir; // 方块的方向（0-3）
};
这里定义了一些常量，包括地图的宽度、高度，以及方块的大小。然后，我们定义了一个结构体Block，用来表示一个方块。这个结构体包含了方块的坐标、类型和方向。

接下来，我们看到了一些全局变量的定义：
int map[HEIGHT][WIDTH]; // 地图
int score = 0; // 分数
int speed = 10; // 速度
这里定义了地图、分数和速度这些全局变量。其中，地图是一个二维数组，用来表示地图上每个位置的状态，0表示空格，1表示填充的方块；分数表示游戏得分；速度表示方块下落的速度。

接着，我们看到了几个函数的定义：initMap()、randomBlock()、canMove(block, dx, dy)和drawBlock(block, val)。

initMap()函数用来初始化地图，将地图上所有方格都设为0。
void initMap() {
memset(map, 0, sizeof(map)); // 将地图所有方格都设为0
}
randomBlock()函数用来随机生成一个方块。首先，定义了7种基本方块形状，每种形状有4个旋转状态。然后，随机选择一种形状和旋转状态，将方块的坐标和类型保存到一个Block结构体中。
Block randomBlock() {
int type = rand() % 7; // 随机选择一种形状
int dir = rand() % 4; // 随机选择一个旋转状态
Block block;
for (int i = 0; i < SIZE; i++) {
block.x[i] = Shapes[type][dir][i][0]; // 保存方块的x坐标
block.y[i] = Shapes[type][dir][i][1]; // 保存方块的y坐标
}
block.type = type; // 保存方块的类型
block.dir = dir; // 保存方块的方向
return block;
}

canMove(block, dx, dy)函数用来判断方块是否可以向某个方向移动。首先，计算出方块在移动后的位置，然后遍历方块的每个小方块，判断是否越界或者和已有方块重叠。如果有任何一个小方块越界或者和已有方块重叠，则说明方块不能移动。
int canMove(Block block, int dx, int dy) {
for (int i = 0; i < SIZE; i++) {
int x = block.x[i] + dx;
int y = block.y[i] + dy;
if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT || map[y][x]) {
return 0;
}
}
return 1;
}
drawBlock(block, val)函数用来在地图上画出一个方块。遍历方块的每个小方块，在地图上对应位置上填上相应的值。这里的val表示填充的颜色，可以是方块的类型，也可以是其他颜色。
void drawBlock(Block block, int val) {
for (int i = 0; i < SIZE; i++) {
int x = block.x[i];
int y = block.y[i];
map[y][x] = val;
}
}
接下来是main()函数的实现。首先，初始化随机数种子和地图，然后不断循环进行游戏。在每次循环中，先判断是否需要生成新的方块。如果需要，就随机生成一个方块，否则就将当前方块下移一格。然后，判断当前方块是否能够向下移动，如果可以就向下移动，否则就将当前方块固定在地图上，更新得分，并检查是否有满行需要消除。最后，更新游戏界面，控制游戏速度，处理玩家输入等操作。

总体来说，这份代码实现了一个基本的俄罗斯方块游戏。它通过不断地生成和移动方块，让玩家进行操作，得分并消除满行来获得胜利。这个游戏的核心算法是方块的移动和碰撞检测，通过一些简单的数学计算和数据结构，实现了一个简单而有趣的游戏。

main函数单独详细分析

下面我来详细分析一下main()函数的实现。

int main() {
srand(time(NULL)); // 初始化随机数种子
initMap(); // 初始化地图

Block curBlock = randomBlock();     // 随机生成一个方块
Block nextBlock = randomBlock();    // 预先生成下一个方块

int score = 0;          // 初始化得分

while (1) {             // 进入游戏循环
    if (needNewBlock) {     // 判断是否需要生成新的方块
        curBlock = nextBlock;       // 当前方块变为下一个方块
        nextBlock = randomBlock();  // 预先生成下一个方块
        needNewBlock = 0;           // 标记为不需要生成新的方块
    } else {
        curBlock.y[0]++;           // 否则将当前方块向下移动一格
        curBlock.y[1]++;
        curBlock.y[2]++;
        curBlock.y[3]++;
    }

    if (!canMove(curBlock, 0, 0)) {  // 判断当前方块是否能够向下移动
        drawBlock(curBlock, curBlock.type);  // 不能移动则将当前方块固定在地图上
        score += clearLine();               // 消除满行并更新得分
        needNewBlock = 1;                   // 标记为需要生成新的方块
    }

    updateGame();         // 更新游戏界面
    controlSpeed();       // 控制游戏速度
    handleInput();        // 处理玩家输入
}

return 0;

}
首先，程序调用srand()函数初始化随机数种子，然后调用initMap()函数初始化地图。接着，程序随机生成一个方块，并将其赋值给curBlock变量，同时预先生成下一个方块并将其赋值给nextBlock变量，初始化得分为0。

然后，程序进入一个无限循环，表示游戏一直在进行中。在每一次循环中，程序首先判断是否需要生成新的方块，这个判断是通过一个名为needNewBlock的全局变量实现的。如果needNewBlock为真，说明需要生成新的方块，程序将nextBlock变量的值赋给curBlock，并预先生成下一个方块赋值给nextBlock，然后将needNewBlock标记为假。

如果needNewBlock为假，说明当前方块还可以向下移动一格，程序将当前方块的每个小方块的y坐标都加上1，表示向下移动一格。

接下来，程序调用canMove()函数判断当前方块是否能够向下移动。如果不能向下移动，说明当前方块已经到达了底部或者已经和其他方块重叠，程序将当前方块固定