c++俄罗斯方块

最新推荐文章于 2024-08-26 09:56:58 发布
最新推荐文章于 2024-08-26 09:56:58 发布
阅读量423 收藏 2
点赞数
文章标签： c 小游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/listfire/article/details/81459584
版权

// tetris.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
typedef struct OBJECT
{
    int irow;
    int icol;
    int type=-1;//类型
    int irowBK;
    int icolBK;
}TETRIS;
enum 
{
    WALL_NULL,
    WALL,
};
enum TETRISTYPE
{
    ZERO,//田
    FIRST,//横
    SECOND,//竖
    FIRTH,//T
    FIVE,//L
    FIRTH_T,
    FIVE_L,
};
TETRIS tetris;
bool b_left = true;
const int ROW=15;
const int COL=10;
int i_map[ROW][COL];
int index = 0;
int index_create = 0;
int i_speed = 2;//下降速度
int i_create_speed = 20;//方块出现速率
vector <TETRIS> ntetris;//对象数组
void initGame();
void drawGame();
void create_tertri();
void move_tetri();
void collier();
void clear_full_row();
void tertri_down();
int main()
{
    initGame();
    while (true)
    {
        system("cls");
        drawGame();
        create_tertri();
        move_tetri();
        collier();
        clear_full_row();
        tertri_down();
        Sleep(80);
    }
    return 0;
}
void initGame()
{
    
    for (int i = 0; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            if (j == COL - 1 || j == 0 || i == ROW - 1) 
            {
                i_map[i][j] = 2;//2为墙
            }
            else
            {
                i_map[i][j] = WALL_NULL;
            }
        }
    }

};
void drawGame()
{
    
    for (int i = 0;i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            bool b_tetris = false;
            for (int n = 0; n < ntetris.size(); n++)
            {
                if (i == ntetris[n].irow&&j == ntetris[n].icol)
                {
                    b_tetris = true;
                }
            }
            if (i_map[i][j] == WALL)
            {
                cout << "■";
            }
            else if (i_map[i][j] == 2)
            {
                cout << "◆";
            }
            else if(b_tetris)
            {
                cout << "□";
            }
            else
            {
                cout << "  ";
            }
        }
        cout << endl;
    }
};
void create_tertri()//创建方块
{
    index_create++;
    if (index_create > i_create_speed&&ntetris.size()<1)
    {
        srand((unsigned)time(NULL));
        int i_number = rand() % 5;
        switch (i_number)
        {
        case 0://田
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 2; j++)
                {
                    tetris.irow = i;
                    tetris.icol = j+5;
                    tetris.type = ZERO;
                    ntetris.push_back(tetris);
                }

            }
            break;
        case 1://竖3
            for (int i = 0; i < 3; i++)
            {
                    tetris.irow = i;//1,2,2,3
                    tetris.icol =3;
                    tetris.type =FIRST;
                    ntetris.push_back(tetris);
            }
            break;
        case 2://横3
            for (int i = 0; i < 3; i++)
            {
                    tetris.irow = 0;
                    tetris.icol = i+3;
                    tetris.type = SECOND;
                    ntetris.push_back(tetris);
            }
            break;
        case 3://T
            for (int i = 0; i < 3; i++)
            {
                
                    tetris.irow = 0;
                    tetris.icol = i+3;
                    tetris.type = FIRTH;
                    ntetris.push_back(tetris);
            }
            for (int i = 0; i < 1; i++)
            {
                tetris.irow = 1;
                tetris.type = FIRTH;
                tetris.icol = 1+3;
                ntetris.push_back(tetris);
            }
            break;
        case 4://L
            for (int i = 0; i < 3; i++)
            {

                tetris.irow = i;
                tetris.icol = 5;
                tetris.type = FIVE;
                ntetris.push_back(tetris);
            }
            for (int i = 0; i < 1; i++)
            {
                tetris.irow = 2;
                tetris.icol =  6+i;
                tetris.type = FIVE;
                ntetris.push_back(tetris);
            }
            break;
        default:
            break;
        }
        index_create = 0;
    }
};
void move_tetri()//移动方块
{
    
    index++;
    if (index > i_speed)
    {
        for (int i = 0; i < ntetris.size(); i++)
        {
            ntetris[i].irow++;
        }
        index = 0;
    }
    if (KEYDOWN(VK_UP))//变形
    {

        if (ntetris.size() > 0) {
            switch (ntetris[0].type)
            {
            case FIRST://横3
                for (int i = 1; i < ntetris.size(); i++)
                {
                    ntetris[i].irow = ntetris[i - 1].irow + 1;
                    ntetris[i].icol = ntetris[0].icol;
                    ntetris[0].type = SECOND;
                }
                break;
            case SECOND://竖3
                for (int i = 1; i < ntetris.size(); i++)
                {
                    ntetris[i].irow = ntetris[0].irow;
                    ntetris[i].icol = ntetris[i - 1].icol + 1;
                    ntetris[0].type = FIRST;
                }
                break;
            case FIRTH://T

                ntetris[ntetris.size() - 1].irow = ntetris[0].irow - 1;

                ntetris[0].type = FIRTH_T;

                break;
            case FIVE://L

                ntetris[ntetris.size() - 1].icol = ntetris[0].icol - 1;

                ntetris[0].type = FIVE_L;

                break;
            case FIRTH_T://T

                ntetris[ntetris.size() - 1].irow = ntetris[0].irow + 1;

                ntetris[0].type = FIRTH;

                break;
            case FIVE_L://L

                ntetris[ntetris.size() - 1].icol = ntetris[0].icol + 1;

                ntetris[0].type = FIVE;

                break;
            }
        }
    }
    
    else if (KEYDOWN(VK_DOWN))
    {

    }
    else if (KEYDOWN(VK_LEFT))
    {
        int i_left=0;
        
        for (int i = 0; i < ntetris.size(); i++)
        {
            if (ntetris[i].icol <=1)
            {
                i_left++;
            }
            if(i_map[ntetris[i].irow][ntetris[i].icol-1]==1)
            {
                i_left++;
            }
        
        }
        for (int i = 0; i < ntetris.size(); i++)
        {
            if (i_left == 0)
            {
                ntetris[i].icol--;
            }

        }
    }
    else if(KEYDOWN(VK_RIGHT))
    {
        int  i_right = 0;
        for (int i = 0; i < ntetris.size(); i++)
        {
            if (ntetris[i].icol>=(COL - 2))
            {
                i_right++;
            }
            if (i_map[ntetris[i].irow][ntetris[i].icol +1] == 1)
            {
                i_right++;
            }
                
        }
        for (int i = 0; i < ntetris.size(); i++)
        {
            if (i_right == 0)
            {
                ntetris[i].icol++;
            }
        }
            
    }
}
void collier() //碰撞
{
    bool b_clear = false;
    for (int i = 0; i < ntetris.size(); i++)
    {
        if ((ntetris[ntetris.size()-1].irow+1)>=(ROW-1)|| i_map[ntetris[i].irow + 1][ntetris[i].icol] == 1)//当前
        {
            b_clear = true;
        }

    }
    if (b_clear)//消除行
    {
        for (int i = 0; i < ntetris.size(); i++)
        {
            i_map[ntetris[i].irow][ntetris[i].icol]= 1;//
        }
        ntetris.clear();
        vector<TETRIS>().swap(ntetris);
        b_clear = false;
        
    }
}
void clear_full_row()
{
    for(int i=0;i<ROW;i++)
    {
        int icout = 0;
        for (int j = 0; j < COL; j++)
        {
            if (i_map[i][j] == 1)
            {
                icout++;
                if (icout == 8)
                {
                    for (int n = 1; n < (COL-1); n++)
                    {
                        i_map[i][n] = 3;
                    }
                }
            }
        }
    }
}
void tertri_down()
{
    for (int i = 1; i < ROW; i++)
    {
        for (int j = 0; j < COL; j++)
        {
            if (i_map[i][j] == 1&& i_map[i + 1][j] ==3)
            {
                
                    i_map[i][j] = 3;
                    i_map[i+1][j] = 1;
            }
            if (i_map[i][j]==3 &&i_map[i - 1][j]==0)
            {
                i_map[i][j] = 0;
            }
        }
    }
}


 

listfire
关注
用C++编绘图控件工具
ahhdsfbff的博客
05-14 878
点开看看吧！！求求
C++ 俄罗斯方块
m0_48077629的博客
05-29 3805
一个简单的俄罗斯方块小游戏。
俄罗斯方块 c++
09-01
俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块俄罗斯方块
探索编译时的奇迹：超级模板俄罗斯方块
最新发布
gitblog_00865的博客
08-26 389
探索编译时的奇迹：超级模板俄罗斯方块 Super-Template-TetrisTetris as a C++ Template Metaprogram 项目地址:https://gitcode.com/gh_mirrors/su/Super-Template-Tetris 在编程的世界里，总有一些创意超出常规，挑战我们对代码极限的认识。今天，让我们一起揭开一款独特开源项目的神秘面纱——超级模板...
俄罗斯方块（c++）
weixin_49324123的博客
10-03 655
#include<stdio.h> #include<graphics.h> #include<Windows.h> #include<time.h> #include<conio.h> int score = 0;//总分 int rank =0;//等级 int NextIndex=-1; //下一个要降落方块的种类 int BlockIndex =1; //本次降落方块的种类 #define BLOCK_COUNT 5 #def.
C++之俄罗斯方块
a15970673567的博客
09-02 1103
C++之俄罗斯方块 使用VS2017编译 思路： 1.打印出游戏地图，也就是设计游戏地图类game_interdace，包括设计游戏开始界面的函数，游戏地图界面的函数，游戏结束界面的函数，以及设计一些辅助函数如（设置光标为目标点，改变颜色，隐藏光标）来完成上述设计。 2.设计方块图形类,包括生成图形，清理图形，图形移动，图形停止的处理，图形的消失（实质是得分）等。 #include <iostream> #include<conio.h> #include<windows.h&
Dev-C++俄罗斯方块源代码
07-14
C++俄罗斯方块源代码
C++俄罗斯方块
04-15
《C++俄罗斯方块》是一款基于C++编程语言开发的经典小游戏，它对于初学者来说是一个很好的实践项目，可以帮助他们巩固C++基础知识，并学习到游戏开发的一些基本原理和技巧。在这个项目中，开发者需要掌握以下几个...
C++ 俄罗斯方块实现 1G视频教程.zip
08-18
在本套"C++ 俄罗斯方块实现 1G视频教程"中，你将深入学习如何使用C++编程语言从零开始构建经典的俄罗斯方块游戏。这个教程覆盖了多个关键的编程概念和技术，对于想要提升C++技能或者对游戏开发感兴趣的初学者来说，...
自己写的c++俄罗斯方块项目
05-05
【C++俄罗斯方块项目】是一个个人开发的编程实践，主要使用C++语言实现经典游戏——俄罗斯方块。在这个项目中，开发者不仅锻炼了C++编程技能，还可能涉及到了图形用户界面（GUI）设计、游戏逻辑算法以及事件处理等...
俄罗斯方块(C++版)
01-27
以前给大家推荐的一个小型绘图库,还答应给大伙写一个示例程序,由于前段时间太忙了,所以这件事一直拖到现在.前两天又承诺一个朋友,帮他写这个绘图库的示例程序,这事不能再拖下去了,而且今天正好事情不多,于是抽空完成了这个示例程序.其中可能还有一些BUG,没有仔细检查出来. 本程序主要是来说明写一个游戏大体的框架,以及如何使用第三方库来完成程序中的功能. 资源中包括了绘图库的引用文件,以及游戏源代码. 编译器:VC6 你也可以在其它编译器中编译.
俄罗斯方块.cpp--经典小游戏大集合(C++ 源码)俄罗斯方块
06-25
俄罗斯方块--经典小游戏大集合(C++ 源码)俄罗斯方块,总共有19种方块，每一种方块都是由4个小格子组成。但其实这19种方块是由7种基本方块通过变形得到的。
俄罗斯方块（C++）
CatchMoon
08-15 5402
俄罗斯方块简易版（C++）
C++ 俄罗斯方块
qq_43382616的博客
01-08 586
C++实现俄罗斯方块 感谢接口实验，在8086上实现俄罗斯方块还是相当酸爽的。。。。 考虑到逻辑的复杂性，就先使用C++实现了算法，以确保算法的正确性，此处放出C++代码，需要注意的是，并没有模拟自动时钟，而是将方块自动下落的时钟改为外部控制： 具体而言，程序运行时的不同种类控制指令如下，需要特别指出的是，n表示时钟，即使得方块按照一定频率自动下落的信号，如果你想要得到俄罗斯方块自动下落一格的下一状态，输入n即可 op: d 直接下落到底 op: l 左移 op: r 右移 op: s 旋转（逆时针） o
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值