俄罗斯方块(=)

最新推荐文章于 2024-09-01 11:50:58 发布
最新推荐文章于 2024-09-01 11:50:58 发布
阅读量657 收藏 4
点赞数 1
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ilsswfr/article/details/50734861
版权

上完一学期的课，一直想试下写俄罗斯方块

嗯 下面这个版本的把原先闪屏和延迟改进了 把掉落最后一行不能移动的BUG也改了下


改进的地方是 ： 

1：下落过程中 以及更新方块的时候，不直接用system("cls")进行清屏

      而是用gotoxy 函数将光标移动到需要改变的位置 先擦除 再更新

2：不直接用Sleep(),用时间 和 输入判断 判断是否进行自动下落,


= = 突然想起来  结果发现两个bug 再改改 


下面改进版的代码

//ILSSWFR
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<conio.h>
#include<string>
#include<cstring>
#include"windows.h"
using namespace std;
void moves(int level,const int *const po,int n,int k,int *flag,int scores,int q,int e,const int *const it);//移动 get
bool ending();//判断是否游戏结束 get
void game_start(int *scores,int *flag,int level);//开始游戏,flag用来记录游戏模式
int rad_pre(int n);//随机下个掉落的方块get
bool judge(int *point,const int *const po,int n);//判断是否可以移动或者下落 get
void print(const int *const po,int n,int arrow);//用来填图已经掉落的方块get
void out(const int *const po,int n,int k,int scores,int q,int e,const int *const it);
int clean(int *score);//用来清除已经可以消去的行以及统计分数 get
void game_start2(int *scores);
int  S[27][10] ;//这个是方格的尺寸
const int FK1[4][3][3]={ {{0,0,0},{1,0,0},{1,1,1}}
                        ,{{1,1,0},{1,0,0},{1,0,0}}
                        ,{{0,0,0},{1,1,1},{0,0,1}}
                        ,{{0,1,0},{0,1,0},{1,1,0}}}
        ,  FK2[4][3][3]={{{0,0,0},{0,0,1},{1,1,1}}
                        ,{{1,0,0},{1,0,0},{1,1,0}}
                        ,{{0,0,0},{1,1,1},{1,0,0}}
                        ,{{1,1,0},{0,1,0},{0,1,0}}}
        ,  FK3[2][3][3]={{{0,0,0},{1,1,0},{0,1,1}}
                        ,{{0,1,0},{1,1,0},{1,0,0}}}
        ,  FK4[2][3][3]={{{0,0,0},{0,1,1},{1,1,0}}
                        ,{{1,0,0},{1,1,0},{0,1,0}}}
        ,  FK5[1][2][2]={{{1,1},{1,1}}}
        ,  FK6[4][3][3]={ {{0,0,0},{0,1,0},{1,1,1}}
                        ,{{0,1,0},{1,1,0},{0,1,0}}
                        ,{{0,0,0},{1,1,1},{0,1,0}}
                        ,{{1,0,0},{1,1,0},{1,0,0}}}
        ,  FK7[2][4][4]={{{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,1,1,1}}
                         ,{{1,0,0,0},{1,0,0,0},{1,0,0,0},{1,0,0,0}}};
const int CH[7]={4,4,2,2,1,4,2};//分别是下落图形的样式 和样式的种类
const int *const po[7]={FK1[0][0],FK2[0][0],FK3[0][0],FK4[0][0],FK5[0][0],FK6[0][0],FK7[0][0]};//指针内存储的是内存单元的地址，因为底层const 所以要用*const
const int speed[9]={0,300,250,200,150,100};
int len[7]={3,3,3,3,2,3,4};//方块的边长
int lo_h=4,lo_l=4,h=0,l=4;
int main()
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_CURSOR_INFO cci;
GetConsoleCursorInfo(hOut,&cci);
cci.bVisible = FALSE;
SetConsoleCursorInfo(hOut,&cci);

    int *start,scores=0,flag=0;
    char choose ;
    for (;;){
        system("cls");
    cout<<"--------------------------"<<endl;
    cout<<"|                        |"<<endl;
    cout<<"|    欢迎进入游戏界面    |"<<endl;
    cout<<"|                        |"<<endl;
    cout<<"--------------------------"<<endl;
    cout<<"|                        |"<<endl;
    cout<<"|                        |"<<endl;
    cout<<"|      1：开始游戏       |"<<endl;
    cout<<"|      2：操作介绍       |"<<endl;
    cout<<"|      3：退出游戏       |"<<endl;
    cout<<"|                        |"<<endl;
    cout<<"|                        |"<<endl;
    cout<<"--------------------------"<<endl;
    choose=getch();
    if (choose=='3')
        return 0;
    else if (choose=='2'){
        system("cls");
        cout<<"游戏模式："<<endl;
        cout<<"         1:传统模式  一共有5个关卡以供选择"<<endl;
        cout<<"         2:无限模式  每次闯关到达1000分自动进入下一关"<<endl<<endl;
        cout<<"分值计算："<<endl<<"          每成功消去一行获得50分"<<endl;
        cout<<"          无法下落时结束游戏"<<endl;
        cout<<"具体操作："<<endl;
        cout<<"          向左：A"<<endl;
        cout<<"          向右：D"<<endl;
        cout<<"          向下：S"<<endl;
        cout<<"          变形：W"<<endl<<endl<<endl;
    system("pause");
    }
    else if (choose=='1'){
        system("cls");
        char cho;
        cout<<"请选择模式："<<endl;
        cout<<"           1：传统模式"<<endl;
        cout<<"           2：无限模式"<<endl;
        cho=getch();
        if (cho=='1'){
            system("cls");
            char level;
            cout<<"请选择关卡(1~5):"<<endl;
            level=getch();
            system("cls");
            cout<<"    READY GO!    "<<endl;
            Sleep(500);
            scores=0;
            game_start(&scores,&flag,level-'0');
       }
        if (cho=='2'){
            system("cls");
            cout<<"    READY GO!    "<<endl;
            Sleep(500);
            game_start2(&scores);
        }

    }
    }
    return 0;
}
int rad_pre(int n)//产生随机值
{
    srand((unsigned)time(NULL));
    return rand()%n;
}

bool ending()//每次涂抹结束后调用这个函数,判断是否结束游戏
{
   for (int i=0;i<4;++i)
        for (int j=0;j<10;++j)
        if (S[i][j]==1)
        return false;
    return true;
}
void gotoxy(int x, int y)
{
    COORD pos;
    pos.X = x;
    pos.Y = y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
void print2(int *p,const int *const fk,int k,int color)//处理图形
{
     for (int i=0;i<len[k];++i){
        for (int j=0;j<len[k];++j){
            if (*(fk+i*len[k]+j)){
            *(p+i*10+j)=color;
        }
       }
    }
}

void print4(const int *const fk,int k)//处理图形
{   gotoxy(22,0);
     for (int i=0;i<len[k];++i){
        for (int j=0;j<len[k];++j){
            if (*(fk+i*len[k]+j))
                cout<<"■";
            else cout<<"  ";

       }
     gotoxy(22,i+1);
    }
}

bool judge(int *point,const int *const po,int n,int k,int arrow)//point是该指针在S中的位置，剩下的是方块的指针,q是列的位置
{                                                     //n是随机的第几个形态 k是这个第K个方块

   int *p=point-10*(len[k]-1);//指向同一

   if (arrow==-1){//左为-1 右为1 下为0
    const int *const fk = po+n*len[k]*len[k];
    print2(p,fk,k,0);
    for (int i=0;i<len[k];++i){
        for (int j=0;j<len[k];++j)
        if (*(fk+i*len[k]+j)&&*(p+i*10-1+j)){
            print2(p,fk,k,1);
           return false;
        }
    }
   }
   if (arrow==1){
        const int *const fk = po+n*len[k]*len[k];
        print2(p,fk,k,0);
        if (lo_l+len[k]>=10){
           for (int i=0;i<len[k];++i)
           if (*(fk+i*len[k]+len[k]-(lo_l+len[k]-10+1))){
                   print2(p,fk,k,1);
                        return false;
           }
        }

        for (int i=0;i<len[k];++i)
        for (int j=0;j<len[k];++j)
        if (*(fk+i*len[k]+j)&&*(p+i*10+j+1)){
             print2(p,fk,k,1); return false;
        }

    }
   if (arrow==0) {
    const int *const fk = po+n*len[k]*len[k];
    print2(p,fk,k,0);
      for (int i=0;i<len[k];++i)
         for (int j=0;j<len[k];++j)
            if (*(p+(i+1)*10+j)&&*(fk+i*len[k]+j)){
                print2(p,fk,k,1); return false;
            }
        }

    if (arrow==3){

        if(lo_l+len[k]>10)
            return false;

        const int *const fuck=po+n*len[k]*len[k];
           print2(p,fuck,k,0);
        const int *const fk = po+((n+1)%CH[k])*len[k]*len[k];


         for(int i=0;i<len[k];++i)
            for (int j=0;j<len[k];++j)
         if (*(p+i*10+j)&&*(fk+len[k]*i+j)){
            print2(p,fuck,k,1); return false;
         }

    }
   return true;
}
int clean(int *score)
{
    int flg=0;
    for (int i=24;i>=4;--i){
            int cnt=0;
        for (int j=0;j<10;++j)
            if (S[i][j]==1) cnt++;

        if (cnt==10){
                flg=1;
            for (int k=i;k>=1;--k)
                for (int j=0;j<10;++j)
                    S[k][j]=S[k-1][j];
            *score+=50;
            i+=1;
        }
    }
    return flg;
}
void print(int *point,const int *const po,int n,int k,int arrow)
{
    const int *const fk = po+n*len[k]*len[k];

    int *p=point-10*(len[k]-1);

    p=point-10*(len[k]-1);
    if (arrow==-1)
        p-=1;
    else if (arrow==1)
        p+=1;
    else if (arrow==3)
        p+=10;

    for (int i=0;i<len[k];++i){
        for (int j=0;j<len[k];++j){
            if (!*(p+i*10+j)){
            *(p+i*10+j)=*(fk+i*len[k]+j);
            }
        }

    }
}
void out(const int *const po,int n,int k,int scores,int q,int e,const int *const it)
{
      system("cls");

    const int *const fk = po+n*len[k]*len[k];
    const int *const kk = it+e*len[q]*len[q];

    for (int i=4;i<24;++i){

        for (int j=0;j<10;++j){
            if (lo_h-i<len[k]&&i<=lo_h&&j>=lo_l&&j-lo_l<len[k]){
                    if (*(fk+(len[k]-lo_h+i-1)*len[k]+j-lo_l)||S[i][j])
                        cout<<"■";
                    else
                        cout<<"□";
            }
            else{
                    if (S[i][j])
                    cout<<"■";
                    else
                    cout<<"□";
            }
        }

        cout<<"| ";
        if (i-4<len[q]&&i>=4)
            for (int j=0;j<len[q];++j)
                if (*(kk+j+(i-4)*len[q]))
                cout<<"■";
                else
                cout<<"  ";

        if (i==10)
            cout<<"分数：";
        if (i==12)
            cout<<scores;
        if (i==22)
            cout<<"1:暂停";
        if (i==23)
            cout<<"2:退出";

        cout<<endl;

    }
    cout<<"---------------------"<<endl;

}

void print3(int *p,const int *const fk,int k,int color)
{

    char fu;
   // fu=getch();
    string m;
    if (color)
        m="■";
    else
        m="□";
     int kf=h-len[k],i;
     if (kf<=0){
       i=-kf-1; kf=0;
     }
     else {
        i=0;kf+=1;
     }



     gotoxy(lo_l*2,kf);
     for (int m=0;i<len[k];++m,++i){
        for (int j=0;j<len[k];++j){
            if (*(p+i*10+j)&&lo_l+j<10)
                cout<<"■";
            else if (lo_l+j<10)
                cout<<"□";
    }
       gotoxy(lo_l*2,kf+m+1);
    }
   //fu=getch();
}
void moves(int level,const int *const poi,int n,int k,int *flag,int scores,int q,int e,const int *const it)//每次开始下落
{
    int *p=&S[lo_h][lo_l];
    const int *const p_fk = poi;
    int kind=n,lens=k;
    int flags=0;
    char choose;
    double star=clock();

    for (;;){

        if (!flags) choose=0;
       // else cout<<choose;
        while ((!kbhit()||!(choose=getch()))&&h+5<24){
              if (int(clock()-star)<level)
                 continue ;
              else {
                star=clock();
              }

            if (judge(p,p_fk,kind%CH[k],lens,0)){

                //
                print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,0);

                print(p,p_fk,kind%CH[k],lens,3);
                lo_h+=1;p+=10;h+=1;

                print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,1);
               //system("pause");
               // out(p_fk,kind%CH[k],lens,scores,q,e%CH[q],it);
                //system("pause");
            }
            else {

                 h=0;l=0;lo_h=4;lo_l=4;
                    return ;
            }
        }

        if (choose=='A'){
          // cout<<choose<<endl;
            if (lo_l-1>=0){
                if (judge(p,p_fk,kind%CH[k],k,-1)){
                   //指针移动
                    print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,0);
                    print(p,p_fk,kind%CH[k],lens,-1);
                    lo_l-=1;p-=1;
                    print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,1);

                }
            }
        }
        else if (choose=='W'){
            if (judge(p,p_fk,kind%CH[k],lens,3)){
                   print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,0);
                   kind++;
                   print(p,p_fk,kind%CH[k],lens,0);
                   print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,1);

                }
        }
        else if (choose=='D'){
            if (judge(p,p_fk,kind%CH[k],lens,1)){
                    print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,0);
                    print(p,p_fk,kind%CH[k],lens,1);

                    lo_l+=1;p+=1;
                    print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,1);
            }
        }
        else if (choose=='S'){
            if(lo_h+1<24){
                if (judge(p,p_fk,kind%CH[k],lens,0)){
                   print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,0);
                   print(p,p_fk,kind%CH[k],lens,3);

                    lo_h+=1;p+=10;h+=1;
                    print3(p-10*(len[k]-1),p_fk+(kind%CH[k])*len[k]*len[k],k,1);
                }
            }
        }
        else if (choose=='1'){
             gotoxy(0,22);
             system("pause");
             gotoxy(0,22);
             for (int i=0;i<20;++i)
             cout<<" ";
        }

        else if (choose=='2'){
            *flag=1; return ;
        }
        if (flags)
        choose=0;
       if (lo_h>=19) {
            if ((!kbhit()||!(choose=getch()))&&(int(clock()-star)>=350)){
                lo_h=4;lo_l=4;h=0;
                return ;
            }
            else{
                flags=1;
            }
        }
    }
}
void CLEAN()
{
    gotoxy(22,0);
    for (int i=0;i<4;++i){
        for (int j=0;j<4;++j)
            cout<<"  ";
        gotoxy(22,i+1);
    }
}
void game_start(int *scores,int *flag,int level)
{
    int *p=&S[lo_h][lo_l];
    int jud=0,LLL=0;

    memset(S,0,sizeof(S));
    int q=rad_pre(7),e=rad_pre(CH[q]);

    for (;;){
        //test
        int k=q,n=e;
        const int *const   kin=po[k];
        q=rad_pre(7);
        e=rad_pre(CH[q]);
        const int *const   it=po[q];
        if (!LLL){
            out(kin,n,k,*scores,q,e%CH[q],it);LLL=1;
        }

        CLEAN();
        print4(it+e*len[q]*len[q],q);

        //system("pause");
        moves(speed[level],kin,n,k,&jud,*scores,q,e,it);//

        if (jud)
            break;
        if (clean(scores))
             out(kin,n,k,*scores,q,e,it);


        if (!ending()){
            system("cls");
            cout<<"您获得的分数是："<<*scores<<endl;
            system("pause");
            return ;
        }
    }
}

void game_start2(int *scores)
{    int *p=&S[lo_h][lo_l];
    int jud=0,LLL=0;

    memset(S,0,sizeof(S));
    int q=rad_pre(7),e=rad_pre(CH[q]);

    for (int level=1;level<=5;){
        //test
        int k=q,n=e;
        const int *const   kin=po[k];
        q=rad_pre(7);
        e=rad_pre(CH[q]);
        const int *const   it=po[q];
        if (!LLL){
            out(kin,n,k,*scores,q,e%CH[q],it);LLL=1;
        }
        CLEAN();
        print4(it+e*len[q]*len[q],q);



        moves(speed[level],kin,n,k,&jud,*scores,q,e,it);//

        if (jud)
            break;
        if (clean(scores))
             out(kin,n,k,*scores,q,e,it);


        if (*scores>=1000){
            level++;
            memset(S,0,sizeof(S));
            *scores=0;
            cout<<"    READY GO!    "<<endl;
            Sleep(500);
            continue;

        }

        if (!ending()){
            system("cls");
            cout<<"您本关获得的分数是："<<*scores<<endl;
            system("pause");
            return ;
        }
    }
    cout<<"您闯过了所有关卡"<<endl;
    system("pause");
}



下面是样例


ilsswfr
关注
专栏目录
Flash俄罗斯方块游戏
09-24
俄罗斯方块游戏 .fla 源代码 对flash感兴趣的 下载看看 演示地址：http://codechina.net/demo/5.swf
陈广C#制作俄罗斯方块 swf5
03-10
陈广C#制作俄罗斯方块 swf格式 体积小，清晰
实战项目：俄罗斯方块(一)
最新发布
weixin_74300052的博客
09-01 1291
Hello,大家好，我是小珑也要变强（也是小珑），我是易编程·终身成长社群的一名“创始团队·嘉宾”和“内容共创官”,现在我来为大家介绍一下有关物联网-嵌入式方面的内容。vt100是一个古老的终端定义，目前大部分的终端都兼容这种终端。vt100控制码是用来在终端扩展显示的代码。所有的控制字符全部以\033打头(即ESC的ASCII码)(\033中的0可以省略)，用输出语句来输出，可以输出不同颜色的字符。在C语言程序中，一般用printf来输出vt100的控制字符。
俄罗斯方块Flash版
04-23
地球人都知道的经典益智游戏，一般情况下无需单独安装Flash播放器。
"FLASH游戏开发示例"学习:俄罗斯方块
weixin_30339457的博客
11-20 290
在网上有很多俄罗斯方块的开源代码，作为一个AS的新手，俄罗斯方块也是有难度的，下面是我从这个例子中的一些粗见： 大家都知道，在玩俄罗斯方块时，是有随机产生的四格拼板随机变换在空的游戏区域垒起来的，然后消除一行行满的格子。 所以要考虑的就有（我是把tetrominoes称为四格拼板）： 1.四格拼板有多少种类，每个种类有不同的变换...
LABVIEW俄罗斯方块
12-02
《 LABVIEW俄罗斯方块：深入理解与学习指南》 LabVIEW，全称为Laboratory Virtual Instrument Engineering Workbench（实验室虚拟仪器工程工作台），是一款由美国国家仪器（National Instruments, NI）公司开发的...
俄罗斯方块C++源代码
09-18
《俄罗斯方块C++源代码解析》 在编程领域，经典游戏俄罗斯方块是一个极好的学习案例，它涉及到了基础的图形界面设计、事件处理、数据结构和算法等多个知识点。本篇文章将对“俄罗斯方块C++源代码”进行深入剖析，...
俄罗斯方块。
Tjohn9的博客
08-02 1780
目录零. 直接上代码代码运行截图一. 基本的游戏知识1.1 下面是这7种基本方块：1.2.游戏规则：二. 思路2.1游戏大体思路2.2 main()函数主要结构三. 编译环境：四. 关于一些函数的解释4.1关于控制台、游戏界面、颜色、光标设置、菜单函数4.1.1 setTitle函数4.1.2 setColor函数4.1.3 setPos函数4.1.4 setGametable函数4.1.5 showMenu函数4.2创建立方块、移动方块、变化方块的函数4.2.1 moveBlock函数4.2.2 prin
Python课程设计之俄罗斯方块
06-27
在本项目中，"Python课程设计之俄罗斯方块"是一个基于Python编程语言实现的经典游戏——俄罗斯方块。这个课程设计旨在帮助学生理解Python的基本语法、控制结构、对象导向编程以及图形用户界面（GUI）的创建。以下是...
俄罗斯方块
10-24
java版俄罗斯方块，双缓冲，swing，可以播放音乐，可以导入项目，运行
俄罗斯方块（陈广教程）
04-19
简单入门c#程序，包括配置窗体、砖块类、砖块生产机、xml文件等内容
flash制作的小游戏-俄罗斯方块
12-23
flash制作的经典小游戏，俄罗斯方块
ActionScript3.0做的Flash小游戏 俄罗斯方块
11-10
用Flash Builder 4做的，上传的是项目源文件。
golang力扣leetcode 699.掉落的方块
清风
05-26 331
699.掉落的方块699.掉落的方块题解代码 699.掉落的方块 699.掉落的方块 题解 题目：相当于俄罗斯方块下落，如果当前方块下面有方块，就会叠上去，给一个方块数组，求每个方块的高度，不过这句话要做修改，是记录目前所有已经落稳的== 方块堆叠的最高高度 ==，即如果当前方块的高度小于之前堆叠的最高高度，当前高度赋值为堆叠的最高高度 思路：很明显的区间查询和区间修改，用线段树来做，可惜我不会，直接用暴力方法 1.遍历方块数组 2.遍历当前方块之前的方块数组 3.如果当前方块与之前的方块重合 则hei
C#俄罗斯方块（陈广简化改进版）
08-19
增加了分数及级别功能，简化了部分功能，自己研究研究吧！！！！！
verilog设计俄罗斯方块_俄罗斯方块_VHDL-FPGA-Verilog_
10-02
《基于FPGA的Verilog实现俄罗斯方块游戏详解》 在现代数字系统设计中，FPGA（Field-Programmable Gate Array）因其可重构性和高速处理能力被广泛应用。结合高级硬件描述语言如Verilog，我们可以实现复杂的功能，...
经典游戏俄罗斯方块Flash源码 Flash游戏源码.RAR
11-24
经典游戏俄罗斯方块Flash源码 Flash游戏源码.RAR
俄罗斯方块（汇编）绝对的经典
10-12
俄罗斯方块（汇编）绝对的经典，127KB大小，经典的汇编应用，偷来的源码哦！仅供分享！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值