用C++写一个俄罗斯方块

好的，以下是一个简单的C++俄罗斯方块实现。

首先，我们需要定义方块的形状。我们可以用一个二维数组来表示每个方块的形状。

const int BLOCK_TYPE_NUM = 7; // 方块种类数
const int BLOCK_SIZE = 4; // 方块大小
const int BLOCK_SHAPE[BLOCK_TYPE_NUM][BLOCK_SIZE][BLOCK_SIZE] = {
    // I
    {
        {0, 0, 0, 0},
        {1, 1, 1, 1},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    },
    // J
    {
        {1, 0, 0, 0},
        {1, 1, 1, 0},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    },
    // L
    {
        {0, 0, 1, 0},
        {1, 1, 1, 0},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    },
    // O
    {
        {1, 1, 0, 0},
        {1, 1, 0, 0},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    },
    // S
    {
        {0, 1, 1, 0},
        {1, 1, 0, 0},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    },
    // T
    {
        {0, 1, 0, 0},
        {1, 1, 1, 0},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    },
    // Z
    {
        {1, 1, 0, 0},
        {0, 1, 1, 0},
        {0, 0, 0, 0},
        {0, 0, 0, 0}
    }
};

接下来，我们需要定义游戏板块。我们可以用一个二维数组来表示每个方块的状态（空或已被占用）。

const int BOARD_WIDTH = 10; // 游戏板块宽度
const int BOARD_HEIGHT = 20; // 游戏板块高度
int board[BOARD_HEIGHT][BOARD_WIDTH] = {0}; // 游戏板块状态

然后，我们需要定义方块的位置和类型。我们可以用两个变量来表示当前方块的位置和类型。

int curX = 0; // 当前方块的x坐标
int curY = 0; // 当前方块的y坐标
int curBlock = 0; // 当前方块的种类

接下来，我们需要定义一些游戏逻辑函数。例如，我们需要定义一个函数来检查当前方块是否可以向下移动。

bool canMoveDown() {
    for (int i = 0; i < BLOCK_SIZE; i++) {
        for (int j = 0; j < BLOCK_SIZE; j++) {
            if (BLOCK_SHAPE[curBlock][i][j] != 0) {
                int x = curX + j;
                int y = curY + i + 1;
                if (y >= BOARD_HEIGHT || board[y][x] != 0) {
                    return false;
                }
            }
        }
    }
    return true;
}

我们还需要定义一些函数来实现方块的移动和旋转。

void moveLeft() {
    if (curX > 0) {
        curX--;
    }
}

void moveRight() {
    if (curX < BOARD_WIDTH - BLOCK_SIZE) {
        curX++;
    }
}

void moveDown() {
    if (canMoveDown()) {
        curY++;
    } else {
        // 当前方块无法向下移动，将其固定到游戏板块中
        for (int i = 0; i < BLOCK_SIZE; i++) {
            for (int j = 0; j < BLOCK_SIZE; j++) {
                if (BLOCK_SHAPE[curBlock][i][j] != 0) {
                    int x = curX + j;
                    int y = curY + i;
                    board[y][x] = curBlock + 1;
                }
            }
        }
        // 检查是否有满行，如果有，将其删除
        for (int i = BOARD_HEIGHT - 1; i >= 0; i--) {
            bool full = true;
            for (int j = 0; j < BOARD_WIDTH; j++) {
                if (board[i][j] == 0) {
                    full = false;
                    break;
                }
            }
            if (full) {
                for (int k = i - 1; k >= 0; k--) {
                    for (int j = 0; j < BOARD_WIDTH; j++) {
                        board[k + 1][j] = board[k][j];
                    }
                }
                for (int j = 0; j < BOARD_WIDTH; j++) {
                    board[0][j] = 0;
                }
                i++;
            }
        }
        // 生成新的方块
        curX = BOARD_WIDTH / 2 - 2;
        curY = 0;
        curBlock = rand() % BLOCK_TYPE_NUM;
    }
}

void rotate() {
    int temp[BLOCK_SIZE][BLOCK_SIZE] = {0};
    for (int i = 0; i < BLOCK_SIZE; i++) {
        for (int j = 0; j < BLOCK_SIZE; j++) {
            temp[i][j] = BLOCK_SHAPE[curBlock][BLOCK_SIZE - j - 1][i];
        }
    }
    for (int i = 0; i < BLOCK_SIZE; i++) {
        for (int j = 0; j < BLOCK_SIZE; j++) {
            BLOCK_SHAPE[curBlock][i][j] = temp[i][j];
        }
    }
}

最后，我们需要定义游戏主循环。在每个循环中，我们需要检查用户输入，更新当前方块的位置和状态，并输出游戏板块的状态。

int main() {
    // 初始化游戏
    srand(time(NULL));
    curBlock = rand() % BLOCK_TYPE_NUM;

    // 游戏主循环
    while (true) {
        // 检查用户输入
        if (kbhit()) {
            int key = getch();
            switch (key) {
                case 'a':
                    moveLeft();
                    break;
                case 'd':
                    moveRight();
                    break;
                case 's':
                    moveDown();
                    break;
                case 'w':
                    rotate();
                    break;
                case 'q':
                    return 0;
            }
        }

        // 更新游戏状态
        if (canMoveDown()) {
            curY++;
        } else {
            moveDown();
        }

        // 输出游戏板块状态
        system("cls");
        for (int i = 0; i < BOARD_HEIGHT; i++) {
            for (int j = 0; j < BOARD_WIDTH; j++) {
                if (board[i][j] == 0) {
                    printf(".");
                } else {
                    printf("%c", 'A' + board[i][j] - 1);
                }
            }
            printf("\n");
        }
        Sleep(100);
    }

    return 0;
}

这就是一个简单的C++俄罗斯方块实现。当然，这只是一个简单的示例，实际的游戏可能会更加复杂和丰富。