俄罗斯方块C++源码

最新推荐文章于 2024-02-28 06:28:58 发布
最新推荐文章于 2024-02-28 06:28:58 发布
阅读量1.4w 收藏 45
点赞数 6
分类专栏： 小游戏 文章标签： 俄罗斯方块 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzh190015/article/details/50740296
版权

源.cpp

//TETRIS
//源.cpp

#include<iostream>
#include<thread>
#include<graphics.h >
#include"tetromino.h"

using namespace std;

bool panel [ 1000 ][ 1000 ];                    //面板,true=空,false=占据
tetromino *p = nullptr;                     //图形
tetromino *nextp = nullptr;                 //下一个图形
int score = 0;                                      //分数
bool loss;                                              //检测是否失败

void start ();                                          //开始
void initpanel ();                          //初始化面板
void createTetromino ();                    //创造图形
void play ();                               //操作方块
void eliminate ();                          //消除方块
void goDown ( thread& );                    //方块下落
void control ();                            //方块控制
void endgame ();                            //游戏结束
bool leftable ( const tetromino& );         //可以向左
bool rightable ( const tetromino& );            //可以向右
bool spinnable ( const tetromino& );        //可以旋转

int main ( void )
{
    start ();
    initpanel ();
    while ( !loss )
    {
        createTetromino ();
        play ();
        eliminate ();
    }
    endgame ();

    return 0;
}

void initpanel ()           //初始化面板
{
    for ( int i = 0; i < WIDTH; i++ )
    {
        for ( int j = 0; j < HEIGHT; j++ )
        {
            panel [ j ][ i ] = true;
        }
    }
}

void createTetromino ()     //创造图形
{
    int choice;
    if ( !( panel [ 0 ][ 4 ] && panel [ 0 ][ 5 ] && panel [ 0 ][ 6 ] ) )
    {
        loss = false;
        endgame ();
    }
    if ( !nextp )
    {
        srand ( time ( 0 ) );
        choice = rand () % 7;
        switch ( choice )
        {
            case I:
                nextp = new tetromino ( I );
                break;
            case J:
                nextp = new tetromino ( J );
                break;
            case L:
                nextp = new tetromino ( L );
                break;
            case O:
                nextp = new tetromino ( O );
                break;
            case S:
                nextp = new tetromino ( S );
                break;
            case Z:
                nextp = new tetromino ( Z );
                break;
            case T:
                nextp = new tetromino ( T );
                break;
        }
        p = nextp;
    }
    else
    {
        p = nextp;
    }
    choice = rand () % 7;
    switch ( choice )
    {
        case I:
            nextp = new tetromino ( I );
            break;
        case J:
            nextp = new tetromino ( J );
            break;
        case L:
            nextp = new tetromino ( L );
            break;
        case O:
            nextp = new tetromino ( O );
            break;
        case S:
            nextp = new tetromino ( S );
            break;
        case Z:
            nextp = new tetromino ( Z );
            break;
        case T:
            nextp = new tetromino ( T );
            break;
    }
    clearrectangle ( 11 * BORDER , 0 , 17 * BORDER , 4 * BORDER );
    for ( int i = 0; i < 4; i++ )
    {
        solidrectangle ( ( 7.5 + nextp->block [ i ].X )*BORDER , ( nextp->block [ i ].Y )*BORDER , ( 8.5 + nextp->block [ i ].X )*BORDER , ( 1 + nextp->block [ i ].Y )*BORDER );
    }
    p->display ();
}

void play ()                                //操作方块
{
    thread controlThread ( control );
    goDown ( controlThread );
}

void goDown ( thread& thr )                  //方块下落
{
    for ( int i = 0; i < HEIGHT; i++ )
    {
        for ( int j = 0; j < 4; j++ )
        {
            if ( !panel [ p->block [ j ].Y + 1 ][ p->block [ j ].X ] || i == HEIGHT - 1 )
            {
                for ( int k = 0; k < 4; k++ )
                {
                    panel [ p->block [ k ].Y ][ p->block [ k ].X ] = false;
                }
                goto JUMPOUT;
            }
        }
        p->moveDown ();
        Sleep ( p->interval );
    }
    JUMPOUT:
    thr.detach ();
}

void control ()                             //方块控制
{
    while ( 1 )
    {
        if ( _kbhit () )
        {
            switch ( _getch () )
            {
                case 'w':
                    if ( spinnable ( *p ) )
                    {
                        p->spin ();
                        p->decelerate ();
                    }
                    break;
                case 'a':
                    if ( leftable ( *p ) )
                    {
                        p->moveLeft ();
                        p->decelerate ();
                    }
                    break;
                case 'd':
                    if ( rightable ( *p ) )
                    {
                        p->moveRight ();
                        p->decelerate ();
                    }
                    break;
                case 's':
                    p->accelerate ();
                    break;
            }
        }
    }
}

void eliminate ()                           //消除方块
{
    bool flag = true;
    int line = true;
    while ( line )
    {
        line = 0;
        for ( int i = 0; i < 20; i++ )
        {
            flag = true;
            for ( int j = 0; j < 10; j++ )
            {
                if ( panel [ i ][ j ] )
                {
                    flag = false;
                }
            }
            if ( flag )
            {
                line = i;
            }
        }
        if ( line )
        {
            score++;
            for ( int i = line; i > 0; i-- )
            {
                for ( int j = 0; j < 10; j++ )
                {
                    panel [ i ][ j ] = panel [ i - 1 ][ j ];
                    if ( !panel [ i ][ j ] )
                    {
                        solidrectangle ( j*BORDER , i*BORDER , ( j + 1 )*BORDER , ( i + 1 )*BORDER );
                    }
                    else
                    {
                        clearrectangle ( j*BORDER , i*BORDER , ( j + 1 )*BORDER , ( i + 1 )*BORDER );
                    }
                }
            }
        }
    }
    clearrectangle ( 11 * BORDER , 5 * BORDER , 16 * BORDER , 9 * BORDER );
    char str [ 5 ];
    sprintf_s ( str , "%d" , score );
    outtextxy ( 13 * BORDER , 7 * BORDER , str );
}

void endgame ()                             //游戏结束
{
    cleardevice ();
    closegraph ();
    cout << "GAME OVER!" << endl << "YOUR SCORE:" << score << endl;
    system ( "pause" );
    exit ( 0 );
}

void start ()                               //开始
{
    initgraph ( 401 , 400 );                //绘图开始
    char str1 [] = "Press any key to start!";
    outtextxy ( 100 , 200 , str1 );
    char str2 [] = "使用WASD操控";
    outtextxy ( 100 , 300 , str2 );
    while ( !_kbhit () );
    cleardevice ();
    line ( 201 , 0 , 201 , 401 );           //竖线
    line ( 0 , 401 , 201 , 401 );           //横线
    rectangle ( 11 * BORDER - 1 , 0 , 16 * BORDER + 1 , 4 * BORDER + 1 );                                           //显示下一图形
    rectangle ( 11 * BORDER - 1 , 5 * BORDER + 1 , 16 * BORDER + 1 , 9 * BORDER + 1 );                  //显示分数  
}

bool leftable ( const tetromino& tet )          //可以向左
{
    for ( int i = 0; i < 4; i++ )
    {
        if ( !panel [ tet.block [ i ].Y ][ tet.block [ i ].X - 1 ] )
        {
            return false;
        }
    }
    return true;
}
bool rightable ( const tetromino& tet )         //可以向右
{
    for ( int i = 0; i < 4; i++ )
    {
        if ( !panel [ tet.block [ i ].Y ][ tet.block [ i ].X + 1 ] )
        {
            return false;
        }
    }
    return true;
}

bool spinnable ( const tetromino& tet )     //可以旋转
{
    for ( int i = 0; i < 4; i++ )
    {
        if ( !panel [ -p->block [ i ].X + p->center.X + p->center.Y ][ p->block [ i ].Y - p->center.Y + p->center.X ] )
        {
            if ( -p->block [ i ].X + p->center.X + p->center.Y <= 10 && p->block [ i ].Y - p->center.Y + p->center.X <= 20 )
            {
                return false;
            }
        }
    }
    return true;
}

tetromino.h

//TETRIS
//tetromino.h

#ifndef TETROMINO_H
#define TETROMINO_H

#define BORDER 20
#define HEIGHT 20
#define WIDTH 20

#include<conio.h>

enum tetromino_type
{
    I , J , L , O , S , Z , T
};

class tetromino                     //图形
{
public:
    tetromino ( tetromino_type index );
    tetromino_type type;

    int interval = 300;       //降落的间隔
    COORD block [ 4 ];     //方块的位置
    COORD center;           //旋转中心

    void display ();         //显示
    void moveLeft ();        //向左移动
    void moveRight ();       //向右移动
    void moveDown ();        //向下移动
    void spin ();            //旋转
    void accelerate ();      //变速
    void decelerate ();      //减速

    bool left ();               //最左
    bool right ();          //最右
};

#endif

tetromino.cpp

//TETRIS
//tetromino.cpp

#include<graphics.h>
#include"tetromino.h"

using namespace std;

tetromino::tetromino ( tetromino_type index )
{
    switch ( index )
    {
        case I:
            block [ 0 ] = { 5 , 0 };
            block [ 1 ] = { 5 , 1 };
            block [ 2 ] = { 5 , 2 };
            block [ 3 ] = { 5 , 3 };
            center = { 5 , 1.5 };
            type = I;
            break;
        case J:
            block [ 0 ] = { 5 , 0 };
            block [ 1 ] = { 5 , 1 };
            block [ 2 ] = { 5 , 2 };
            block [ 3 ] = { 4 , 2 };
            center = block [ 1 ];
            type = J;
            break;
        case L:
            block [ 0 ] = { 5 , 0 };
            block [ 1 ] = { 5 , 1 };
            block [ 2 ] = { 5 , 2 };
            block [ 3 ] = { 6 , 2 };
            center = block [ 1 ];
            type = L;
            break;
        case O:
            block [ 0 ] = { 5 , 0 };
            block [ 1 ] = { 6 , 0 };
            block [ 2 ] = { 5 , 1 };
            block [ 3 ] = { 6 , 1 };
            center = { 5.5 , 0.5 };
            type = O;
            break;
        case S:
            block [ 0 ] = { 6 , 0 };
            block [ 1 ] = { 5 , 0 };
            block [ 2 ] = { 5 , 1 };
            block [ 3 ] = { 4 , 1 };
            center = block [ 1 ];
            type = S;
            break;
        case Z:
            block [ 0 ] = { 4 , 0 };
            block [ 1 ] = { 5 , 0 };
            block [ 2 ] = { 5 , 1 };
            block [ 3 ] = { 6 , 1 };
            center = block [ 1 ];
            type = Z;
            break;
        case T:
            block [ 0 ] = { 4 , 0 };
            block [ 1 ] = { 5 , 0 };
            block [ 2 ] = { 6 , 0 };
            block [ 3 ] = { 5 , 1 };
            center = block [ 1 ];
            type = T;
            break;
    }
}

void tetromino::display ()         //显示
{
    for ( int i = 0; i < 4; i++ )
    {
        solidrectangle ( block [ i ].X*BORDER , block [ i ].Y*BORDER , ( block [ i ].X + 1 )*BORDER , ( block [ i ].Y + 1 )*BORDER );
    }
}
void tetromino::moveLeft ()        //向左移动
{
    if ( !left () )
    {
        for ( int i = 0; i < 4; i++ )
        {
            clearrectangle ( block [ i ].X*BORDER , block [ i ].Y*BORDER , ( block [ i ].X + 1 )*BORDER , ( block [ i ].Y + 1 )*BORDER );
            block [ i ].X--;
        }
        center.X--;
        display ();
    }
}
void tetromino::moveRight ()       //向右移动
{
    if ( !right () )
    {
        for ( int i = 0; i < 4; i++ )
        {
            clearrectangle ( block [ i ].X*BORDER , block [ i ].Y*BORDER , ( block [ i ].X + 1 )*BORDER , ( block [ i ].Y + 1 )*BORDER );
            block [ i ].X++;
        }
        center.X++;
        display ();
    }
}
void tetromino::moveDown ()        //向下移动
{
    for ( int i = 0; i < 4; i++ )
    {
        clearrectangle ( block [ i ].X*BORDER , block [ i ].Y*BORDER , ( block [ i ].X + 1 )*BORDER , ( block [ i ].Y + 1 )*BORDER );
        block [ i ].Y++;
    }
    center.Y++;
    display ();
}

void tetromino::spin ()                 //旋转
{
    if ( type != O )
    {
        for ( int i = 0; i < 4; i++ )
        {
            clearrectangle ( block [ i ].X*BORDER , block [ i ].Y*BORDER , ( block [ i ].X + 1 )*BORDER , ( block [ i ].Y + 1 )*BORDER );
            int x = block [ i ].X;
            int y = block [ i ].Y;
            block [ i ].X = y - center.Y + center.X;
            block [ i ].Y = -x + center.X + center.Y;
        }
        display ();
    }
}

void tetromino::accelerate ()           //加速
{
    interval = 100;
}

void tetromino::decelerate ()          //减速
{
    interval = 300;
}

bool tetromino::left ()                 //最左
{
    for ( int i = 0; i < 4; i++ )
    {
        if ( block [ i ].X == 0 )
        {
            return true;
        }
    }
    return false;
}

bool tetromino::right ()
{
    for ( int i = 0; i < 4; i++ )
    {
        if ( block [ i ].X == 9 )
        {
            return true;
        }
    }
    return false;
}
wzh190015
关注
  • 6
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
俄罗斯方块C++源代码
09-18
功能齐全，可以保存游戏进度，根据得分自动调整难度，一次性消去多行得分有加权，可玩可学习
C++实现——简易版俄罗斯方块
csdncyn的博客
02-17 273
用C++实现简单的俄罗斯方块游戏功能
俄罗斯方块编程代码实现,俄罗斯方块小游戏代码
最新发布
2301_81900386的博客
02-28 390
大家好，小编来为大家解答以下问题，如何用代码制作俄罗斯方块游戏，俄罗斯方块编程代码实现，现在让我们一起来看看吧！嗨！多一嘴： 代码较长，但是附有超级详细的注释，大家耐心看完哦~
俄罗斯方块的源码实现
NEWPLAN的专栏
03-24 1万+
介绍俄罗斯方块（Tetris， 俄文：Тетрис）是一款电视游戏机和掌上游戏机游戏，它由俄罗斯人阿列克谢·帕基特诺夫发明，故得此名。俄罗斯方块的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。由于上手简单、老少皆宜，从而家喻户晓，风靡世界。源码#include <stdio.h> #include <string.h> #include <stdlib.h
C++实现俄罗斯方块（源码+详解）
IT OR 考公？
08-11 8386
18746字，所有代码，直接复制可玩
使用C++做一个俄罗斯方块
lhr110729的博客
05-21 803
这是一个简单的俄罗斯方块游戏示例，使用了控制台输出来显示游戏界面。游戏逻辑和渲染逻辑被分别放在了两个循环中，通过不断更新屏幕缓冲区来实现动态效果。你可以根据需要对代码进行修改和扩展，以满足你的需求。
C语言版 彩色俄罗斯方块 控制台输出
u014726694的博客
10-28 7600
源码： ///////////////////////////////////////////////////////////////////////////////////////////////// // 名称： 俄罗斯方块 彩色版1.1.0// // 语言： C语言
c/c++ 实现俄罗斯方块小游戏（附全部源码）
热门推荐
q841447739的博客
08-11 1万+
使用easyX库，基于c/c++，实现俄罗斯方块小游戏。（附全部源码）
C++ 实现俄罗斯方块
weixin_30882895的博客
04-11 198
C++ 实现俄罗斯方块 一、实验介绍 1.1 实验内容 本节实验我们进行设计俄罗斯方块前的思路分析，以及介绍ncurses 库的使用方法。 1.2 实验知识点 C++ 编程基础 ncurses 库的使用 俄罗斯方块逻辑设计 1.3 实验环境 xfce 终端 g++ 编译器 ncurses 库 1.4 适合人群 本课程难度一般，适合有 C++ 编程基础，对游戏设计、逻辑分析感兴趣的同学。 1.5 代...
俄罗斯方块 C++控制台版
一只大鸽子的博客
02-03 850
一、创建方块 wstring tetromino[7]; tetromino[0].append(L"..X...X...X...X."); // Tetronimos 4x4 tetromino[1].append(L"..X..XX...X....."); tetromino[2].append(L".....XX..XX....."); tetromino[3].append(L"..X..XX..X......"); tetromino...
用C++实现俄罗斯方块(Tetris)游戏
aang7888的博客
01-20 1694
我是一个C++初学者，控制台实现了一个俄罗斯方块游戏。 代码如下： //"俄罗斯方块"V1.0 //李国良于2017年1月20日编写完成 #include <iostream> #include <string> #include <ctime> #include <cstdlib> #include <windows.h> #...
控制台俄罗斯方块C++源码
12-29
基于C++控制台窗体绘图（GDI）的小游戏，俄罗斯方块，回调函数处理消息，有完整的实现逻辑，包括计分关卡机制，下一个方块预览，游戏文字说明等
一个控制台俄罗斯方块C++源代码及可执行程序
01-31
一个控制台俄罗斯方块C++源代码及可执行程序。
Dev-C++俄罗斯方块源代码
07-14
C++俄罗斯方块源代码
使用Dev c++实现小游戏俄罗斯方块 C++版
03-31
该资源可以为喜欢游戏设计的人，有一定了解的学习，了解每一步的设计，这里有源码，可执行文件，不涉及高深的知识，一步一步来，萌新拿到就可以运行的，欢迎咨询
C++俄罗斯方块源码完整功能版
08-31
C++俄罗斯方块源码完整功能版是C++俄罗斯方块源码 ，控制台程序 ，c++入门上手经典实战上手项目。俄罗斯方块源码,理解透彻,稍作修改即可。
俄罗斯方块c++源码（windows）
11-04
c++源码编译的俄罗斯方块，在windows下运行，原生vc6环境，可提取源码转换
C++实现俄罗斯方块 实例源码下载
12-26
使用C++写的俄罗斯方块，压缩文件中有源代码和VS2013建的项目。
俄罗斯方块c++源码
12-29
俄罗斯方块是一款经典的益智游戏，它的源代码通常由各种编程语言编写而成，比如C语言。俄罗斯方块的源代码通常包括游戏的逻辑实现、图形界面的设计、游戏音效等部分。 在C语言中实现俄罗斯方块游戏，首先需要定义...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值