C语言实现俄罗斯方块游戏

最新推荐文章于 2024-07-21 19:42:40 发布
最新推荐文章于 2024-07-21 19:42:40 发布
阅读量172 收藏
点赞数 1
分类专栏： C语言 游戏 文章标签： c语言 游戏 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/New_Teen/article/details/134190366
版权

文章目录

1 前言

本文介绍的是我空闲时间用C语言写的一个俄罗斯方块游戏，整个程序只有一个文件，实现了基本的游戏功能，但还是有些缺陷，希望有心之士能够继续完善，感谢各位！

2 游戏截图

请注意！a、d、s、w都是小写

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

3 源代码

/*
author: New_Teen
time: 2023.11.2 20:14 周四
IDE: visual studio 2019
俄罗斯方块
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <stdbool.h>
#include <conio.h>

#define BOARD_CUBE ' '
#define WIDTH 15
#define HEIGHT 15
#define FLUSH_RATE 200

char curr_cube;
int curr_square;
int curr_x, curr_y;
int score = 0;
int start_number = 0;
char board[HEIGHT][WIDTH];
int tmp[4][2];
int square[5][4][4] = { {{1,0,0,0},
                        {1,0,0,0},
                        {1,0,0,0},
                        {1,0,0,0}},

                        {{1,0,0,0},
                        {1,1,1,0},
                        {0,0,0,0},
                        {0,0,0,0}},

                        {{0,1,0,0},
                        {1,1,1,0},
                        {0,0,0,0},
                        {0,0,0,0}},

                        {{1,1,0,0},
                        {1,1,0,0},
                        {0,0,0,0},
                        {0,0,0,0}},

                        {{0,1,0,0},
                        {1,1,0,0},
                        {1,0,0,0},
                        {0,0,0,0}} };

void init_board(); //初始化游戏面板
void clear_board(); //清空控制台
void delay_board(); //延时
void print_board(); //打印游戏面板
void init_square(); //初始化方块
void drop_square(); //方块默认下落
void update_board(); //更新游戏面板
bool is_collision_left(); //检测方块左侧是否碰撞
bool is_collision_right(); //检测方块右侧是否碰撞
bool is_collision_bottom(); //检测方块下方是否碰撞
bool is_collsion_rotate(); //检测方块是否可以旋转
bool is_game_over(); //检测游戏是否结束
void rotate(); //旋转方块
void rush_board(); //消除成层方块（得分）
void start_game(); //游戏开始面板

int main() {
    srand((unsigned)time(NULL)); //根据程序执行时间产生随机数种子
    start_game();
    init_board();
    while (1) {
        init_square();
        if (is_game_over())
            break;
        for (;;) {
            if (!is_collision_bottom())
                drop_square();
            else
                break;

            if (_kbhit()) {
                char ch = _getch();
                if (ch == 'a' && !is_collision_left())
                    curr_x--;
                else if (ch == 'd' && !is_collision_right())
                    curr_x++;
                else if (ch == 's' && !is_collision_bottom())
                    curr_y++;
                else if (ch == 'w' && !is_collsion_rotate())
                    rotate();
            }

            update_board();
            rush_board();
            print_board();
            delay_board();
            clear_board();
        }
    }
    printf("Game over!!\nYour score is %d\n", score);
    return 0;
}

void init_board() {
    for (int i = 0; i < HEIGHT; ++i)
        for (int j = 0; j < WIDTH; ++j)
            board[i][j] = BOARD_CUBE;
}

void clear_board() {
    system("cls");
}

void delay_board() {
    Sleep(FLUSH_RATE);
}

void print_board() {
    for (int i = 0; i < HEIGHT; ++i) {
        for (int j = 0; j < WIDTH; ++j)
            putchar(board[i][j]);
        puts("#");
    }
    puts("################");
    printf("score: %d\n", score);
}

void init_square() {
    curr_cube = "ABCDEFGH"[rand()%8];
    start_number == 1 ? curr_square = 0 : curr_square = rand() % 5;
    curr_x = WIDTH / 2, curr_y = -4;
    int count = 0;
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            if (square[curr_square][i][j]) {
                tmp[count][0] = curr_y + i;
                tmp[count][1] = curr_x + j;
                count++;
            }
}

void drop_square() {
    curr_y++;
}

void update_board() {
    //清除之前位置的方块
    int row, col;
    for (int i = 0; i < 4; ++i) {
        row = tmp[i][0];
        col = tmp[i][1];
        if (row >= 0 && row < HEIGHT
            && col >= 0 && col < WIDTH)
            board[row][col] = BOARD_CUBE;
    }

    int count = 0;
    //画出现在位置的方块，并更新tmp
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            row = curr_y + i;
            col = curr_x + j;
            if (square[curr_square][i][j]) {
                tmp[count][0] = row;
                tmp[count][1] = col;
                count++;
                if (row >= 0 && row < HEIGHT
                    && col >= 0 && col < WIDTH)
                    board[row][col] = curr_cube;
            }
        }
    }
}

bool is_collision_left() {
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
            if (square[curr_square][i][j]) {
                //检测方块与面板左墙壁的碰撞
                if (curr_x + j <= 0)
                    return true;
                //检测方块与左侧方块的碰撞
                if (j == 0) {
                    if (board[curr_y + i][curr_x + j - 1] != BOARD_CUBE)
                        return true;
                }
                else {
                    if (!square[curr_square][i][j - 1] && 
                        board[curr_y + i][curr_x + j - 1] != BOARD_CUBE)
                        return true;
                }
            }
    return false;
}

bool is_collision_right() {
    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
            if (square[curr_square][i][j]) {
                //检测方块与面板右墙壁的碰撞
                if (curr_x + j >= WIDTH-1)
                        return true;
                //检测方块与右侧方块的碰撞
                if (j == 3) {
                    if (board[curr_y + i][curr_x + j + 1] != BOARD_CUBE)
                        return true;
                }
                else {
                    if (!square[curr_square][i][j + 1] &&
                        board[curr_y + i][curr_x + j + 1] != BOARD_CUBE)
                        return true;
                }
            }
    return false;
}

bool is_collision_bottom() {
    //找到当前方块的最下层
    int low = -99;
    for (int i = 0; i < 4; i++) 
        for (int j = 0; j < 4; j++)
            if (square[curr_square][i][j] == 1)
                low = i;
    //如果达到面板最底部
    if(curr_y + low >= HEIGHT-1)
        return true;

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            //考虑方块下面有方块的情况
            if (i < 3) {
                if (square[curr_square][i][j] && !square[curr_square][i + 1][j]
                    && (curr_y + i + 1 >=0) && board[curr_y + i + 1][curr_x + j] != BOARD_CUBE)
                    return true;
            }
            else {
                if (square[curr_square][i][j] && (curr_y + i + 1 >= 0) 
                    && board[curr_y + i + 1][curr_x + j] != BOARD_CUBE)
                    return true;
            }
        }
    }
    return false;
}

bool is_collsion_rotate() {
    int middle[4][4] = { 0 };
    //暂存旋转后方块
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            middle[i][j] = square[curr_square][j][i];
    //旋转后方块是否与面板已有方块重叠
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            if (!square[curr_square][i][j] && middle[i][j]
                && board[curr_y + i][curr_x + j] != BOARD_CUBE)
                return true;
    return false;
}

void rotate() {
    //清除之前位置的方块
    int row, col;
    for (int i = 0; i < 4; ++i) {
        row = tmp[i][0];
        col = tmp[i][1];
        if (row >= 0 && row < HEIGHT
            && col >= 0 && col < WIDTH)
            board[row][col] = BOARD_CUBE;
    }

    //旋转方块
    int rotate_tmp[4][4] = { 0 };
    memcpy(rotate_tmp, square[curr_square], 16 * sizeof(int));
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            square[curr_square][i][j] = rotate_tmp[j][i];
    
    int count = 0;
    //画出现在位置的方块，并更新tmp
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            row = curr_y + i;
            col = curr_x + j;
            if (square[curr_square][i][j]) {
                tmp[count][0] = row;
                tmp[count][1] = col;
                count++;
                if (row >= 0 && row < HEIGHT
                    && col >= 0 && col < WIDTH)
                    board[row][col] = curr_cube;
            }
        }
    }
}

bool is_game_over() {
   for (int j = 0; j < WIDTH; ++j)
       if (board[0][j] != BOARD_CUBE)
           return true;          
    return false;
}

void rush_board() {
    int count, floor;
    floor = 0;
    for (int i = HEIGHT - 1; i >= 0; --i) {
        count = 0;
        for (int j = 0; j < WIDTH; ++j)
            if (board[i][j] != BOARD_CUBE)
                count++;
        if (count == WIDTH)
            floor++;
        else
            break;
    }

    //得到floor后，面板下移floor层
    if (floor != 0) {
        for (int i = HEIGHT - 1 - floor; i >= 0; --i)
            for (int j = 0; j < WIDTH; ++j)
                board[i + floor][j] = board[i][j];
        score += floor;
    }
}

void start_game() {
    printf("----------------俄罗斯方块----------------\n");
    printf("\n游戏规则：a:左移  d:右移  s:下移  w:旋转\n");
    printf("\n输入1：全程长条方块     输入2：经典随机方块\n");
    while (start_number != 1 && start_number != 2) {\
        printf("\n请输入序号（1或者2）: ");
        scanf_s("%d", &start_number);
    }
    clear_board();
}
New_Teen
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
华为OD机试(C卷,200分)- 二叉树计算
欢迎来到我的博客~
07-20 726
6、递归处理左区间右区间并计算每个节点的childSum，新树的每个节点的值 = 其左右子树的所有节点值之和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。请由该二叉树生成一个新的二叉树，它满足其树中的每个节点将包含原始树中的左子树和右子树的和。2行整数，第1行表示二叉树的中序遍历，第2行表示二叉树的前序遍历，以空格分割。1行整数，表示求和树的中序遍历，以空格分割。输出 0 3 0 7 0 2 0。2、前序数组第一个元素为根节点。1、前序数组为0，空节点。
入门C语言只需一个星期（星期五)
最新发布
m0_45463480的博客
07-21 314
");return 0;}函数由两部分组成​void myFunction() { // 声明 declaration // 函数体（要执行的代码）(definition)}Declaration 声明函数名称、返回类型和参数 (如果有)Definition 函数体 (要执行的代码)// 函数声明void myFunction();// 主要方法int main() { myFunction();// --> 调用函数 return 0;
【C语言】动态内存管理（上）
tianxiawushanu的博客
07-21 689
在本文中主要是介绍了为什么要进行动态内存开辟，以及我们在动态内存开辟的时所要用到的一部分函数——malloc、calloc、free，还用它们在使用上面的一些细节。干货满满！！！
华为OD机试2024年C卷D卷 - 构成指定长度字符串的个数/字符串拼接（Java）
Run
07-21 156
给定 M（0 < M ≤ 30）个字符（a-z），从中取出任意字符（每个字符只能用一次）拼接成长度为 N（0 < N ≤ 5）的字符串，如果当前轮次当前层选择的元素 和 之前轮次该层选择的元素的值相同，那么就可以终止当前轮次的当前分支的后续探索，因此必然会产生重复。此时可以通过预处理，对元素进行排序，确保相同元素相邻，再进行递归全排列就只需跟前一子树比较判断，而无需全部比较。要求相同的字符不能相邻，计算出给定的字符列表能拼接出多少种满足条件的字符串，输入非法或者无法拼接出满足条件的字符串则返回0。
C基础入门题：石头剪刀布
我就知道你会来，我们一起进步吧！
07-14 426
简单明了的规则，使得石头剪子布没有任何规则漏洞可钻，单次玩法比拼运气，多回合玩法比拼心理博弈，使得石头剪子布这个古老的游戏同时用于“意外"与“技术”两种特性深受世界人民喜爱。接下来 N 行的每一行包括两个字符串，表示游戏参与者 Player1，Player2 的选择(石头、剪子或者是布):S1,S2。输出包括 N 行，每一行对应一个胜利者(Player1 或者 Player2)，或者游戏出现平局，则输出 Tie。现在，需要你写一个程序来判断石头剪子布游戏的结果。游戏规则:石头打剪刀，布包石头，剪刀剪布，
C语言：函数递归
2403_82759827的博客
07-17 305
C语言：函数递归
【视觉SLAM】 十四讲ch5习题
weixin_68880273的博客
07-18 1044
介绍了《视觉SLAM十四讲》的ch5习题
C语言 | Leetcode C语言题解之第263题丑数
m0_59237910的博客
07-20 336
C语言 | Leetcode C语言题解之第263题丑数
Unity3D 如何读取策划给定的Excel表格详解
Thomas_YXQ的博客
07-17 921
在游戏开发中，策划人员经常使用Excel表格来管理和维护游戏中的各种数据，如角色属性、装备信息、关卡配置等。Unity3D作为一个强大的游戏引擎，本身并不直接支持读取Excel文件，但我们可以通过一些方法间接实现这一功能。本文将详细介绍如何在Unity3D中读取策划给定的Excel表格，并提供相应的技术详解和代码实现。
【保卫花果山】游戏
xiaolizi66936的博客
07-18 333
拯救花果山是一款很多小伙伴都会能参与挑战的冒险小游戏，这是发生在花果山的故事，接下来你会成为一名救世主的，你的任务就是去与各种妖魔作战，能不能拯救世界就看你的了，有很多内容都会的期待的，游戏的时候你的反应一定要快，不然的话，失败了就得不尝试，得重新来过。
初识godot游戏引擎并安装
轻编程的博客
07-21 342
Godot是一款自由开源、由社区驱动的2D和3D游戏引擎。游戏开发虽复杂，却蕴含一定的通用规律，正是为了简化这些通用化的工作，游戏引擎应运而生。Godot引擎作为一款功能丰富的跨平台游戏引擎，通过统一的界面支持创建2D和3D游戏。它提供了一套全面的通用工具，使得用户能够专注于游戏制作本身，无需从头开始构建基础功能。
Unity点击生成节点连线
w091253的博客
07-19 161
Unity点击生成节点连线
Model Import Settings
UniMark的博客
07-19 857
在可视化3D世界中，模型是3D世界的核心，你可以没有贴图，可以没有特效，甚至可以没有用户交互界面，但必须得有模型来描述世界的基本样貌。在3D世界中，由点线面构成了模型的轮廓；由UV和纹理，共同描述模型的样貌；由骨骼和蒙皮信息描述模型的运动姿态；再由骨骼的运动轨迹描述模型在某个时间段内的肢体动作。
2024-07-20 Unity插件 Odin Serializer2 —— 序列化教程
zheliku的博客
07-20 812
​ 如果已有需要继承的特定基类型，则通过实现 Unity 的 ISerializationCallbackReceiver 接口并使用 Odin 的 UnitySerializationUtility 类，可以在需要的地方自行实现序列化。自定义 Odin-serialized自定义 Odin-serialized} }​ 使用 SerializationUtility 类，该类包装序列化系统并处理所涉及的所有样板代码。
Unity 导入MRTK，使用URP 升级材质，MRTK的材质还是洋红色
o_ojjj的博客
07-18 248
选择最后一个，这个是MRTK自带的，点击把可以材质升级成URP。点击URP的升级材质并不能把MRTK的材质进行升级。
UE4-打包游戏，游戏模式，默认关卡
weixin_52159554的博客
07-18 212
如果没有安装可以通过在 编辑器开始界面，创建C++项目来让编译器来帮我们安装，这样安装我们项目需要用到C++插件编译器都会帮我们安装好。如果打包完画面自动跳转到网页，那么说明此时我们电脑的Visual Studio环境没有配置好。注意windows系统无法打包苹果系统的执行包，只能使用苹果系统打包。在这个界面可以配置游戏的默认地图和游戏的模式，对项目中所有关卡都生效。编辑器打开时默认打开那个地图，和游戏打包后默认打开那个地图。2.设置默认加载的关卡和游戏模式。选择我们打包的项目是开发版还是发行版本。
Unity3D URP 后处理如何作用于 UI 控件 Image 的详解
Thomas_YXQ的博客
07-18 419
另一种方法是将UI渲染到一个RenderTexture上，然后将这个RenderTexture作为相机的一个附加层（Overlay），这样UI就可以被相机的后处理效果所影响。由于URP的后处理默认作用于相机渲染的3D场景，而UI是独立于相机渲染的，因此直接应用后处理效果到UI控件Image上并不直接支持。这个Camera需要设置为只渲染UI层，并放置在场景中的适当位置。现在，UI已经被渲染到RenderTexture上，并且可以通过主相机（或其他任何相机）显示，这个相机应用了URP的后处理效果。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 1483
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
Unity 调试死循环程序
thinbug的专栏
07-19 175
如果游戏出现死循环如何调试呢。
"C语言实现俄罗斯方块游戏详解
作业要求使用C语言实现俄罗斯方块游戏，并且提示我们可以使用graphics.h来实现。在作业布置后的两天，我们开始了准备工作。师傅建议在项目开始前进行充分的构思和规划，确保我们明确需求并规划好开发流程。于是，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

New_Teen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值