C语言入门项目——俄罗斯方块源码

最新推荐文章于 2025-03-07 23:15:30 发布
最新推荐文章于 2025-03-07 23:15:30 发布
阅读量1.6k 收藏 17
点赞数 4
分类专栏： C语言入门开发 文章标签： C语言 源码 新手 入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43365952/article/details/103222598
版权
这篇博客介绍了一个适合C语言初学者的入门项目——俄罗斯方块的源码实现，包括view.h、view.cpp、model.cpp、model.h和tetris.cpp等关键文件的详细内容，是理解C语言编程和游戏开发的良好实践。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录


本代码运行环境是 Windows下的VS2013
首先创建 tetris.cpp
然后依次创建 view.h以及 view.cpp、 model.h以及 model.cpp。
代码如下：

view.h

#pragma once
#include <stdio.h>
void ShowBackground();
void ShowBrick();
void ShowGame();
void OnLeft();
void OnRight();
void OnUp();
void OnDown();

view.cpp

#include <stdlib.h>
#include "view.h"
#include "model.h"
void OnLeft()
{//如果能够左移，则左移
    if (IsCanMove(g_nRow, g_nCol - 1))
    {
        g_nCol--;
        ShowGame();
    }
}

void OnRight()
{
    if (IsCanMove(g_nRow, g_nCol + 1))
    {
        g_nCol++;
        ShowGame();
    }
}

void OnUp()
{
    if (IsCanRotate())
    {
        Rotate();
        ShowGame();
    }
}

void OnDown()
{
    if (IsCanMove(g_nRow+1, g_nCol))
    {
        g_nRow++;
        ShowGame();
    }
    else
    {
        //固定方块至背景，并且产生新方块
        CombineBgBrick();
        GetNewBrick();
        //判断游戏是否结束，并给出对应提示
    }
}

void ShowGame()
{
    system("cls");
    CombineBgBrick();
    ShowBackground();
    DetachBgBrick();
}
void ShowBrick()
{
    for (size_t i = 0; i < 4; i++)
    {
        for (size_t j = 0; j < 4; j++)
        {
            if (g_chBrick[i][j] == 1)
            {
                printf("■");
            }
        }
    printf("\r\n");
    }
}

void ShowBackground()
{
    for (size_t nRow = 0; nRow < GAME_ROWS; nRow++)
    {
        for (size_t nCol = 0; nCol < GAME_COLS; nCol++)
        {
            if (g_chBackground[nRow][nCol] == 1)
            {
                printf("■");
            }
            else
            {
                printf("□");
            }
        }
        printf("\r\n");
    }
}

model.cpp

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "model.h"


char g_chBackground[GAME_ROWS][GAME_COLS];
char g_chBrick[4][4];
int g_nShape = 0; //是长条还是方块，系数为16
int g_nRotate = 0; //朝向，系数为4
int g_nRow = 0;
int g_nCol = 0;
char g_chBrickPool[][4] = {
// 长条
1, 1, 1, 1,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,

1, 0, 0, 0,
1, 0, 0, 0,
1, 0, 0, 0,
1, 0, 0, 0,

1, 1, 1, 1,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,

1, 0, 0, 0,
1, 0, 0, 0,
1, 0, 0, 0,
1, 0, 0, 0,

// T形
1, 1, 1, 0,
0, 1, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,

0, 1, 0, 0,
1, 1, 0, 0,
0, 1, 0, 0,
0, 0, 0, 0,

0, 1, 0, 0,
1, 1, 1, 0,
0, 0, 0, 0,
0, 0, 0, 0,

1, 0, 0, 0,
1, 1, 0, 0,
1, 0, 0, 0,
0, 0, 0, 0,

//L形状
1, 0, 0, 0,
1, 0, 0, 0,
1, 1, 0, 0,
0, 0, 0, 0,

1, 1, 1, 0,
1, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,

1, 1, 0, 0,
0, 1, 0, 0,
0, 1, 0, 0,
0, 0, 0, 0,

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

int IsCanRotate()
{
    char chNextShape[4][4] = { 0 };
    int nNextRotate = (g_nRotate + 1) % 4;
    int nPoolRows = g_nShape * 16 + nNextRotate * 4;
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            chNextShape[nRow][nCol] = g_chBrickPool[nRow + nPoolRows][nCol];
        }
    }
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            if (chNextShape[nRow][nCol] == 1)
            {
                if (g_chBackground[nRow + g_nRow][nCol + g_nCol] == 1)
                {
                    return 0; //不能移动
                }
            }
        }
    }
    return 1;
}

void Rotate()
{
    g_nRotate = (g_nRotate + 1) % 4;
    int nPoolRows = g_nShape * 16 + g_nRotate*4;
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            g_chBrick[nRow][nCol] = g_chBrickPool[nRow + nPoolRows][nCol];
        }
    }
}

int IsCanMove(int nToRow, int nToCol)
{
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            if (g_chBrick[nRow][nCol] == 1)
            {
                if (g_chBackground[nRow + nToRow][nCol + nToCol] == 1)
                {
                    return 0; //不能移动
                }
            }
        }
    }
    return 1;
}

void GetNewBrick()
{
    srand((unsigned)time(NULL));
    g_nRow = 0;
    g_nCol = GAME_COLS / 2 - 1;
    int nShapeCount = sizeof(g_chBrickPool) / sizeof(g_chBrickPool[0]) /16;
    g_nShape = rand() % nShapeCount;
    g_nRotate = rand() % 4;
    int nPoolRows = g_nShape * 16 + g_nRotate * 4;
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            g_chBrick[nRow][nCol] = g_chBrickPool[nRow+nPoolRows][nCol];
        }
    }
}

void DetachBgBrick()
{
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            if (g_chBrick[nRow][nCol] == 1)
            {
                g_chBackground[nRow + g_nRow][nCol + g_nCol] = 0;
            }
        }
    }
}

void CombineBgBrick()
{//组合块
    for (size_t nRow = 0; nRow < 4; nRow++)
    {
        for (size_t nCol = 0; nCol < 4; nCol++)
        {
            if (g_chBrick[nRow][nCol] == 1)
            {
                g_chBackground[nRow+g_nRow][nCol+g_nCol] = 1;
            }
        }
    }
}

void InitBackground()
{//初始化背景
    for (size_t nRow = 0; nRow < GAME_ROWS; nRow++)
    {
        for (size_t nCol = 0; nCol < GAME_COLS; nCol++)
        {
            if (nRow == GAME_ROWS - 1
            || nCol == 0
            || nCol == GAME_COLS - 1)
            {
                g_chBackground[nRow][nCol] = 1;
            }
            else
            {
                g_chBackground[nRow][nCol] = 0;
            }
        }
    }
}

model.h

#pragma once

#define GAME_ROWS 20
#define GAME_COLS 12

extern char g_chBackground[GAME_ROWS][GAME_COLS];
extern char g_chBrick[4][4];
extern int g_nRow;
extern int g_nCol;

void InitBackground();
void GetNewBrick();
void CombineBgBrick();
void DetachBgBrick();
int IsCanMove(int nToRow, int nToCol);
void Rotate();
int IsCanRotate();

tetris.cpp

#include "stdafx.h"
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include "model.h"
#include "view.h"


int main(int argc, char* argv[])
{
    InitBackground();
    GetNewBrick();
    CombineBgBrick();
    ShowBackground();
    DetachBgBrick();
    char chInput = 0;
    clock_t clkStart = clock();
    clock_t clkEnd = clock();
    while (1)
    {
        clkEnd = clock();
        if (clkEnd - clkStart > 1000)
        {
            clkStart = clkEnd;
            OnDown();
        }
        if (_kbhit() != 0)
        {
            chInput = _getch();
        }
        switch (chInput)
        {
        case 'a':
            OnLeft();
            break;
        case 'w':
            OnUp();
            break;
        case 's':
            OnDown();
            break;
        case 'd':
            OnRight();
            break;
        default:
            break;
        }
        chInput = 0;
    }
    return 0;
}
【C语言】俄罗斯方块的源代码
菜鸟成长记
05-05 10万+
GitHub：【C语言】实现俄罗斯方块源代码Head.h#ifndef _HEAD_H_ #define _HEAD_H_#include<graphics.h> #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<time.h> #include<string.h> #define _CRT_SECURE_NO_WARNI
编程娱乐之俄罗斯方块
The most secret blogs
06-25 1005
#include #include #include #include //游戏窗口 #define FrameX 4 //游戏窗口左上角的X轴坐标 #define FrameY 4 //游戏窗口左上角的Y轴坐标 #define Frame_height 20 //游戏窗口的高度 #define Frame_width 18 //游戏窗口的宽度 //定义全局
C语言俄罗斯方块源代码
10-30
绝对可以运行，是之前作为大作业的作品，只是运行时需要自己创建头文件，把我头文件部分复制过去即可
C++期末大作业:俄罗斯方块（附源码详解及美工素材）
最新发布
2401_88959292的博客
03-07 2201
俄罗斯方块相信大家都玩过，本游戏也是采用了经典的俄罗斯方块游戏规则：按方向键← →进行左右移动，↑ 进行方块的顺时针旋转，↓进行方块的迅速下落，消行可获得分数，累计获得一定分数可进入下一关，下落速度也会随之变快。本项目使用的是EasyX图形库。那废话不多说，下面就进行代码实现吧。
俄罗斯方块c语言源代码
05-07
c语言俄罗斯方块程序加源代码 c语言学习互相交流 程序源自《c语言程序设计从入门到精通》
C语言编写俄罗斯方块（源代码）
01-28
纯C语言编写的C控制台小游戏俄罗斯方块，直接创建工程加入这个.c文件就可以运行。
C语言实战项目：俄罗斯方块源码分享
标题和描述中提到的知识点主要涉及C语言源码以及一个特定项目——俄罗斯方块小游戏的源代码。这个项目可以作为学习C语言编程的实战案例，能够帮助开发者理解如何从头开始构建一个完整的程序。 ### C语言源码概念 ...
依据c语言Turbo C下写的俄罗斯方块毕业设计源码
03-18
本资源提供了一个基于C语言的毕业设计项目——在Turbo C环境下实现的俄罗斯方块游戏源码。这个项目不仅展示了C语言的基本应用，还涵盖了游戏开发的一些核心概念，对于学习C语言和游戏编程的学生来说是一份宝贵的参考...
Turbo C环境下用C语言编写的俄罗斯方块源码
- **C语言实例开发源码——c语言Turbo C下写的俄罗斯方块.zip**：此描述再次强调资源的内容，即包含了俄罗斯方块游戏的源代码文件，且这些文件是为Turbo C编译器设计的。此外，文件被压缩成一个zip格式的压缩包，...
C语言 俄罗斯方块 控制台单线程实现 程序与源码
12-31
本篇将深入探讨如何利用C语言在控制台环境下，单线程实现经典游戏——俄罗斯方块。通过这个项目，我们可以了解到C语言的基本语法、控制结构以及数据结构的应用。 首先，我们要明确游戏的基本逻辑。俄罗斯方块的核心...
俄罗斯方块源码(C语言)
12-29
《俄罗斯方块源码解析——基于C语言》 在编程世界中，经典的俄罗斯方块游戏是初学者学习游戏开发的入门实例。这个“俄罗斯方块源码”项目，使用C语言编写，虽然简陋，但对于了解游戏编程的基本原理，尤其是中断、...
俄罗斯方块C语言源代码
10-16
俄罗斯方块C语言源代码，附有详细中文解释，适合C语言初学者，简单易懂，对于提高C语言应用能力有很大帮助。
俄罗斯方块游戏源代码 C语言实现
10-25
C语言实现的俄罗斯方块游戏源代码以及.exe可执行文件。含有密码登陆设计以及定时器设计。
C语言实现俄罗斯方块源代码
01-20
本文实例为大家分享了C语言实现俄罗斯方块的具体代码，供大家参考，具体内容如下 GitHub：【C语言】实现俄罗斯方块源代码 Head.h #ifndef _HEAD_H_ #define _HEAD_H_ #include #include #include #include #include #include #define _CRT_SECURE_NO_WARNINGS 1 //界面的相关的参数 #define WALL_SQUARE_WIDTH 10 //围墙方块的宽度
C语言编写的俄罗斯方块（附源码）
11-06
API：Windows API 工具：VC++6.0 （源码都有注释的，供大家学习，写的不好的地方请不吝赐教） 今年刚毕业的，自从学习C语言以来，一直有一个小小的愿望——“自己动手写一个俄罗斯方块”，今天终于实现了，查了很多资料，包括DOS下的编程、SDL、OPENGL等等，最后还是确定用Windows API来做，刚好要学习Windwos编程 游戏说明：左右键控制方向，下键加速，上键变形，空格暂停
C语言---------俄罗斯方块（源代码）
热门推荐
qq_44926123的博客
06-27 2万+
#include<stdio.h> #include<windows.h>//字体颜色，窗口 #include<conio.h> #include<stdlib.h> #include<time.h> #include <mmsystem.h> #pragma comment(lib,“winmm.lib”) #define ...
C语言俄罗斯方块游戏源代码
m0_38073539的博客
10-09 1321
*显示当前的方块，每种方块的颜色不同*//*方块下落完毕，取得下一个方块*/NextAct=random(8);/*取得下一个方块*/PreAct=random(8);/*取得当前的方块*//*控制方块的下落速度*//*方块开场从游戏空间的中间下落*/DrawNext(1);/*画出下一个方块*/NoPass=CAN;/*物体可以下落*//*游戏的算法精华所在*/void Down() /*方块下降*/) /*以下是游戏流程*//*取开场的状态*//*取得当前的方块*/
C语言写俄罗斯方块源码—
Cづ拖延症患者
08-22 1923
#include <graphics.h>#include <stdio.h>#include <stdlib.h>char x,y,ty,ty1,zhuan,line1=0,line2=0,ss[16],hol[10][29]={0},a[4][2]={0};int score1=0,speed=1000;void unit(char,char,char); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值