俄罗斯方块（简单的C语言小游戏）

最新推荐文章于 2024-09-12 19:19:28 发布
最新推荐文章于 2024-09-12 19:19:28 发布
阅读量1.5k 收藏 29
点赞数 41
文章标签： c++ c语言 c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37374226/article/details/136098451
版权

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/time.h>
#include <time.h>
#include <unistd.h>
#include <termios.h>
#include <stdbool.h>

#define   ROW    19     // 游戏区域的行数
#define   COL    12     // 游戏区域的列数
#define    NR    4  // 方块数据大小
#define    TYPE  7  // 方块类型数
/* 按键枚举 */
enum key {
   DOWN,     // 上
   LEFT,     // 左
   RIGHT,    // 右
   CHANGE,   // 变化
   STOP,     // 停止
   EXIT,     // 退出
   UNKNOW,   // 未知
};

/***** 函数声明区域 ******/
void initalGameArea(void);                  // 初始化游戏区域
void drawBlock(char bl[NR][NR]);            // 画方块
void cleanBlock(char bl[NR][NR]);           // 清除方块
void turnBlock(char bl[NR][NR]);            // 旋转方块
void gameEnd(void);                         // 结束游戏
void gameStop(void);                        // 暂停游戏
void showGame(void);                        // 显示游戏
void gameSelf(int signo);                   // 游戏自动运行
void checkDeleteLine(void);                 // 检查是否满一行
void checkGameOver(char bl[NR][NR]);        // 检查是否游戏结束
int  checkMove(char bl[NR][NR], int flag);  // 检查方块是否可移动
void  setBufferedInput(bool enable);                        // 获取输入

/* 全局变量区域 */
static char gameArea[ROW][COL] = {0};    // 游戏区域数据
static int startX = 4, startY = 6;       // 方块出现的起始位置
static int type = 0;                     // 方块当前类型
static int nextType = 0;                 // 方块的下一种类型
static int diret = 0;                    // 方块的方向
char *state = "\033[32m游戏中...\033[0m"; // 游戏运行状态
static unsigned int level = 0;           // 游戏等级
static unsigned int score = 0;           // 游戏分数
static unsigned int maxScore = 0;        // 游戏最高记录
static FILE *fp = NULL;                  // 用于把记录保存到文件

/* 方块数据 */
char bl[TYPE][NR][NR][NR] = {
    /* 第一种方块 */
 {
   { /* 第一种方向 */
    {1,1,0,0},
    {1,1,0,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},
   },
   { /* 第三种方向 */
    {1,1,0,0},
    {1,1,0,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},
   },
 },

 /* 第二种方块 */
 {
   { /* 第一种方向 */
    {2,2,2,2},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第二种方向 */
    {0,2,0,0},
    {0,2,0,0},
    {0,2,0,0},
    {0,2,0,0},
   },
   { /* 第三种方向 */
    {2,2,2,2},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第四种方向 */
    {0,2,0,0},
    {0,2,0,0},
    {0,2,0,0},
    {0,2,0,0},
   },
 },

 /* 第三种方块 */
 {
   { /* 第一种方向 */
    {3,0,0,0},
    {3,3,3,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第二种方向 */
    {0,3,3,0},
    {0,3,0,0},
    {0,3,0,0},
    {0,0,0,0},
   },
   { /* 第三种方向 */
    {3,3,3,0},
    {0,0,3,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第四种方向 */
    {0,0,3,0},
    {0,0,3,0},
    {0,3,3,0},
    {0,0,0,0},
   },
 },

 /* 第四种方块 */
 {
   { /* 第一种方向 */
    {0,0,4,0},
    {4,4,4,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第二种方向 */
    {0,4,0,0},
    {0,4,0,0},
    {0,4,4,0},
    {0,0,0,0},
   },
   { /* 第三种方向 */
    {0,4,4,4},
    {0,4,0,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第四种方向 */
    {0,4,4,0},
    {0,0,4,0},
    {0,0,4,0},
    {0,0,0,0},
   },
 },

 /* 第五种方块 */
 {
   { /* 第一种方向 */
    {0,5,0,0},
    {5,5,5,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第二种方向 */
    {0,5,0,0},
    {0,5,5,0},
    {0,5,0,0},
    {0,0,0,0},
   },
   { /* 第三种方向 */
    {5,5,5,0},
    {0,5,0,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第四种方向 */
    {0,5,0,0},
    {5,5,0,0},
    {0,5,0,0},
    {0,0,0,0},
   },
 },

 /* 第六种方块 */
 {
   { /* 第一种方向 */
    {6,6,0,0},
    {0,6,6,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第二种方向 */
    {0,0,6,0},
    {0,6,6,0},
    {0,6,0,0},
    {0,0,0,0},
   },
   { /* 第三种方向 */
    {6,6,0,0},
    {0,6,6,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第四种方向 */
    {0,0,6,0},
    {0,6,6,0},
    {0,6,0,0},
    {0,0,0,0},
   },
 },

 /* 第七种方块 */
 {
   { /* 第一种方向 */
    {0,7,7,0},
    {7,7,0,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第二种方向 */
    {0,7,0,0},
    {0,7,7,0},
    {0,0,7,0},
    {0,0,0,0},
   },
   { /* 第三种方向 */
    {0,0,7,7},
    {0,7,7,0},
    {0,0,0,0},
    {0,0,0,0},
   },
   { /* 第四种方向 */
    {0,7,0,0},
    {0,7,7,0},
    {0,0,7,0},
    {0,0,0,0},
   },
  },
};



/*
 * 主函数：控制全局流程
*/
int main(void)
{
    /*
     * 设置闹钟：
     * 当前时间间隔为0.7秒，下一次时间间隔为0.7秒
    */
    struct itimerval  timer = {{0,700000},{0,700000}};
    setitimer(ITIMER_REAL, &timer,NULL);

    /* 初始化游戏区域 */
    initalGameArea();

    /* 设置游戏信号 */
    signal(SIGALRM, gameSelf);

    /* 初始化方块类型 */
    srand(time(NULL));
    type     = rand()%7;
    nextType = rand()%7;

    /* 读取文件的最高记录 */
    fp = fopen("./record","r+");
    if (NULL == fp)
    {
        /*
         * 文件不存在则创建并打开 
         * "w"方式打开会自动创建不存在的文
         */
        fp = fopen("./record","w");
    }
    fscanf(fp,"%u",&maxScore);

    /* 用户操作 */
char c;
    int key;
setBufferedInput(false);
    while (1)
    {
        c=getchar();
switch(c) {
case 97: // 'a' key
case 104: // 'h' key
case 68: // left arrow
case 52: // 4 arrow
key = LEFT;  break;
case 100: // 'd' key
case 108: // 'l' key
case 67: // right arrow
case 54: // 6 arrow
key = RIGHT; break;
case 119: // 'w' key
case 107: // 'k' key
case 65: // up arrow
case 50: // 2 arrow
key = CHANGE;    break;
case 115: // 's' key
case 106: // 'j' key
case 66: // down arrow
case 56: // 8 arrow
key = DOWN;  break;
case 32: //space
key=STOP;break;
default: key = UNKNOW;
}

        switch (key)
     {
         case RIGHT : checkMove(bl[type][diret],RIGHT);
                      break;
         case LEFT  : checkMove(bl[type][diret],LEFT);
                      break;
         case DOWN  : checkMove(bl[type][diret],DOWN);
                      break;
         case CHANGE: turnBlock(bl[type][(diret+1)%4]);
                      break;
         case STOP  : gameStop();
                      break;
         case EXIT  : gameEnd();
                      break;
         case UNKNOW: continue;
     }

        /* 画方块 */
        drawBlock(bl[type][diret]);

        /* 显示游戏 */
        showGame();

        /* 清除方块 */
        cleanBlock(bl[type][diret]);
    }

    return 0;
}
void setBufferedInput(bool enable) {
static bool enabled = true;
static struct termios old;
struct termios new;

if (enable && !enabled) {
// restore the former settings
tcsetattr(STDIN_FILENO,TCSANOW,&old);
// set the new state
enabled = true;
} else if (!enable && enabled) {
// get the terminal settings for standard input
tcgetattr(STDIN_FILENO,&new);
// we want to keep the old setting to restore them at the end
old = new;
// disable canonical mode (buffered i/o) and local echo
new.c_lflag &=(~ICANON & ~ECHO);
// set the new settings immediately
tcsetattr(STDIN_FILENO,TCSANOW,&new);
// set the new state
enabled = false;
}
}
/*
 * 函数名：initalGameArea
 * 函数功能：初始化游戏区域
 * 参数：无
 * 返回值：无
*/
void initalGameArea(void)
{
    int i;

/* 屏幕设置 */
printf("\033[2J");   // 清屏
    system("stty -icanon");   // 关缓冲
    system("stty -echo");   // 关回显
    fprintf(stdout,"\033[?25l");  // 关闭鼠标显示

    /* 初始化行 */
    for (i = 0; i < COL; i++)
    {
        gameArea[0][i]     = 8;   // 第0行
        gameArea[5][i]     = 8;   // 第5行
        gameArea[ROW-1][i] = 8;   // 最后一行
    }

    /* 初始化列 */
    for (i = 0; i < ROW; i++)
    {
        gameArea[i][0]     = 8;  // 第0列
        gameArea[i][COL-1] = 8;  // 最后一列
    }

    /* 中间一小列 */
    for (i = 1; i < 5; i++)
    {
        gameArea[i][6] = 8;
    }
}


/*
 * 函数名：gameSelf
 * 函数功能：作为信号函数，闹钟时间一到就自动下落
 * 参数：信号
 * 返回值：无
*/
void gameSelf(int signo)
{
    /* 画方块 */
    drawBlock(bl[type][diret]);

    /* 显示游戏 */
    showGame();

    /* 清除方块 */
    cleanBlock(bl[type][diret]);

    /* 如果方块已经到底 */
    if (!checkMove(bl[type][diret],DOWN))
    {
     /* 检查是否游戏结束 */
     checkGameOver(bl[type][diret]);

     /* 保留已经到底的方块 */
     drawBlock(bl[type][diret]);

     /* 显示游戏结果 */
     showGame();

     /* 到达边界后检查是否可消行 */
     checkDeleteLine();

     /* 重新开始下一个方块 */
     startY = 6;
     startX = 4;
     type = nextType;
     nextType = rand()%7;
     diret = 0;
    }
}

/*
 * 函数名：checkDeleteLine
 * 函数功能：检查是否可消行
 * 参数：无
 * 返回值：无
*/
void checkDeleteLine(void)
{
    int i, j;
    int x, y;

    /* 检查当前方块的四行区域内 */
    for (i = 3; i >= 0; i--)
    {
        for (j = 1; j < COL-1; j++)
     {
         /* 检测方块是否满一行 */
         if (gameArea[startY+i][j] == 0)
             break;
         /* 跳过边框区域 */
         else if (gameArea[startY+i][j] == 8)
             break;
     }
     /* 如果满了一行则删除一行 */
     if (j == COL-1)
     {
         /* 删除满了的一行 */
         for (j = 1; j < COL-1; j++)
         {
             gameArea[startY+i][j] = 0;
         }

         /* 分数累加 */
         score += 100;

         /* 记录最高分 */
         if (score > maxScore)
         {
             maxScore = score;

         /* 保存最高分 */
                rewind(fp);
         fprintf(fp,"%u\n",maxScore);
         }

         /* 记录级别 */
         if (score%200 == 0)
         {
         /* 每200分加一级 */
             level++;
         }

         /* 删除后往下移动一行 */
         for (x = 1; x < COL-1; x++)
         {
             for (y = startY+i; y >= 7; y--)
         {
             gameArea[y][x] = gameArea[y-1][x];
         }
         }

         /* 移动的一行需要检测范围加一行 */
         i++;
     }
    }
}

/*
 * 函数名：checkGameOver
 * 函数功能：检查游戏是否结束
 * 参数：待检查方块数据数据
 * 返回值：无
*/
void checkGameOver(char block[NR][NR])
{
    int i;

    for (i = 0; i < NR; i++)
    {
        /* 方块碰到上方边界则游戏结束 */
        if (block[0][i] != 0 && gameArea[startY-1][startX+i] == 8)
     {
         gameEnd();
     }
    }
}

/*
 * 函数名：turnBlock
 * 函数功能：旋转方块
 * 参数：需要旋转的方块数组数据
 * 返回值：无
*/
void turnBlock(char bl[NR][NR])
{
    int x, y;

    /* 检查是否越界 */
    for (y = 0; y < NR; y++)
    {
        for (x = 0; x < NR; x++)
     {
         /* 只能判断到达了边界 */
         if (bl[y][x] != 0 && gameArea[startY+y][startX+x] != 0)
         {
             return;
         }
     }
    }

    /* 两边都没有越界则旋转方块方向 */
    diret = (diret+1)%4;
}

/*
 * 函数名：gameStop
 * 函数功能：暂停游戏，等待用户再次启动游戏
 * 参数：无
 * 返回值：无
*/
void gameStop(void)
{
    /* 创建一个暂停的是时钟 */
    struct itimerval stop = {0}, older;

    /* 设置新闹钟并存储旧闹钟 */
    setitimer(ITIMER_REAL,&stop,&older);

    /* 配置暂停后的界面 */
    state = "\033[31m暂停中...\033[0m";
    startY--;             // 为了防止按下暂停键后方块下滑一格
    drawBlock(bl[type][diret]);
    showGame();
    cleanBlock(bl[type][diret]);

    /* 等待用户按开始键或退出键 */
    int key;
    while (1)
    {
        key =getchar();;

     /* 空格开始 */
     if (key == ' ')
         break;

     /* q 退出 */
     else if (key == 'q')
         gameEnd();
    }

    /* 恢复闹钟和游戏 */
    setitimer(ITIMER_REAL,&older,NULL);
    state = "\033[32m游戏中...\033[0m";
}

/*
 * 函数名：checkMove
 * 函数功能：检查方块是否可移动,能移则移
 * 参数：1.方块数组数据 2.方向标志位
 * 返回值：可移动返回1，不能移动返回0
*/
int checkMove(char bl[NR][NR], int flag)
{
    int m, n;   // 用于标明可移动方向
    int x, y;   // 用于循环

    switch (flag)
    {
        case RIGHT : n = 0; m = 1;  break;
     case LEFT  : n = 0; m = -1; break;
     case DOWN  : n = 1; m = 0;  break;
    }

    /* 全局检查 */
    for (y = 0; y < NR; y++)
    {
        for (x = 0; x < NR; x++)
     {
         /* 只能判断到达了边界 */
         if (bl[y][x] != 0 && gameArea[startY+y+n][startX+x+m] != 0)
            {
                return 0;
            }
     }
    }

    /* 出来说明没有到达边界 */
    startY += n;
    startX += m;

    return 1;
}



/*
 * 函数名：drawBlock
 * 函数功能：填充方块数据
 * 参数：方块数组数据
 * 返回值：无
*/
void drawBlock(char block[NR][NR])
{
    int x, y;

    /* 画当前方块 */
    for (y = 0; y < NR; y++)
    {
        for (x = 0; x < NR; x++)
     {
         if (block[y][x] != 0)
            {
                gameArea[startY+y][startX+x] = block[y][x];
            }
     }
    }

    /* 画提示的下一个方块 */
    for (x = 0; x < 2; x++)
    {
        for (y = 0; y < NR; y++)
     {
         if (bl[nextType][0][x][y] != 0)
             gameArea[3+x][2+y] = bl[nextType][0][x][y];
            else
             gameArea[3+x][2+y] = 0;
     }
    }
}

/*
 * 函数名：cleanBlock
 * 函数功能：清除方块数据
 * 参数：方块数组数据
 * 返回值：无
*/
void cleanBlock(char bl[NR][NR])
{
    int x, y;

    for (y = 0; y < NR; y++)
    {
        for (x = 0; x < NR; x++)
     {
         if (bl[y][x] != 0)
            {
                gameArea[startY+y][startX+x] = 0;
            }
     }
    }
}

/*
 * 函数名：showGame
 * 函数功能：显示游戏
 * 参数：无
 * 返回值：无
*/
void showGame(void)
{
    int i, j;

    /* 定位到第一行第一列 */
    fprintf(stdout,"\033[1;1H");
    fflush(stdout);

    /* 打印所有数据 */
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
     {
            if (gameArea[i][j] == 0)       // 空白区域
            {
                fprintf(stdout,"  ");
            }
         else if (gameArea[i][j] == 8)  // 边界区域
            {
                fprintf(stdout,"\033[43m  \033[0m");
            }
            else                           // 方块区域
            {
                fprintf(stdout,"\033[%dm[]\033[0m",gameArea[i][j]+40);
            }
     }
    fputc('\n',stdout);
    }

    /* 打印提示信息 */
    fprintf(stdout,"\033[2;3H\033[33m【下一个】\033[0m\n");
    fprintf(stdout,"\033[2;15H当前级别:\033[36m%u\033[0m\n",level);
    fprintf(stdout,"\033[3;15H当前分数:\033[32m%u\033[0m\n",score);
    fprintf(stdout,"\033[4;15H最高记录:\033[35m%u\033[0m\n",maxScore);
    fprintf(stdout,"\033[5;15H当前状态:%s\n",state);

    fprintf(stdout,"\033[7;25H2键翻转");
    fprintf(stdout,"\033[8;25H4,6,8 左右下");
    fprintf(stdout,"\033[9;25H空格键暂停");
}

/*
 * 函数名：gameEnd
 * 函数功能：处理游戏结束的设置
 * 参数：无
 * 返回值：无
*/
void gameEnd(void)
{
    /* 配置游戏结束后的界面 */
    state = "\033[31m游戏结束!!\033[0m";
    drawBlock(bl[type][diret]);
    showGame();

    /* 恢复终端设置 */
    system("stty icanon");          // 恢复缓冲
    system("stty echo");            // 恢复回显
    fprintf(stdout,"\033[?25h");    // 恢复鼠标显示

    /* 尾部处理 */
    fprintf(stdout,"\033[200;1H");  // 定位光标到最后一行
    fclose(fp);                     // 关闭文件
    exit(0);                        // 退出程序
}

E先生。
关注
C语言项目小游戏之俄罗斯方块
sclwc的博客
07-18 1747
今天给大家带来一个用C语言实现的俄罗斯方块小游戏游戏截图：首先我们先创建一个名为mywindows.h的头文件。用来设置我们操作台的各种功能实现。
回忆大学时刚学会C语言时写的俄罗斯方块小游戏
weixin_33860147的博客
07-25 173
1993年，记得刚学会C语言，就试着写了个俄罗斯广块的小程序，微机课上机实习时带着程序一阵敲打和调试，终于把程序跑通了，看着丑陋的大方块从屏幕上端缓缓落下，这时老师走了过来说禁止玩游戏，我告诉他正在调试自己写的小程序，他看了看后无趣的走开了。 今天翻出来以前的代码，发现当时根本不知道软件工程是什么，代码中一行注释也没有，缩进也混乱，到处都充满着神奇的数字。   #include &lt;gr...
SQL开发俄罗斯方块游戏
最新发布
Tony.Dong的专栏
09-12 160
使用 SQL 开发一个简单的俄罗斯方块游戏。
俄罗斯方块（C语言实现）
热门推荐
2021dragon的博客
08-14 17万+
文章目录游戏说明游戏效果展示游戏代码游戏代码详解游戏框架构建隐藏光标光标跳转初始化界面初始化方块信息颜色设置画出方块空格覆盖合法性判断游戏主体逻辑函数判断得分与结束主函数 游戏说明 俄罗斯方块相信大家都知道，这里就不再介绍什么游戏背景了，我这里对本代码实现的俄罗斯方块作一些说明： 按方向键的左右键可实现方块的左右移动。 按方向键的下键可实现方块的加速下落。 按空格键可实现方块的顺时针旋转。 按Esc键可退出游戏。 按S键可暂停游戏，暂停游戏后按任意键继续游戏。 按R键可重新开始游戏。 除此之外，本游戏还
C语言源码实现俄罗斯方块
ww120624的博客
03-25 1462
俄罗斯方块（Tetris， 俄文：Тетрис）是一款电视游戏机和掌上游戏机游戏，它由俄罗斯人阿列克谢·帕基特诺夫发明，故得此名。俄罗斯方块的基本规则是移动、旋转和摆放游戏自动输出的各种方块，使之排列成完整的一行或多行并且消除得分。由于上手简单、老少皆宜，从而家喻户晓，风靡世界。这篇文章主要为大家详细介绍了C语言源码实现俄罗斯方块，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。
C语言实现俄罗斯方块游戏程序设计【附源码】
qq_19774249的博客
01-14 6179
俄罗斯方块游戏，是俄罗斯人阿莱克斯·帕伊特诺夫在八十年代末制作一款游戏，以其规则简单，容易上手，游戏过程变化无穷，已经成为一个家喻户晓老少皆宜的大众游戏。该程序是完成一个简易的俄罗斯方块的任务，其通过结构体、指针、绘图等方面的知识完成几个重要的功能：界面，方块下落，旋转，判断是否还能下落，左右移动，分数，速度设置，清除满的每行，下个方块的预览等。
C语言俄罗斯方块小游戏
02-26
《C语言俄罗斯方块小游戏详解》 在计算机科学的学习过程中，开发小游戏是锻炼编程技能、理解算法和数据结构的有效方式。本项目“C语言俄罗斯方块小游戏”是针对本科课程设计的一项任务，旨在通过实现这一经典游戏，...
C语言写俄罗斯方块.rar
05-29
本篇将详细介绍如何利用C语言编写经典的休闲游戏——俄罗斯方块。首先，我们要理解C语言的基本语法和结构，然后逐步构建游戏的核心逻辑。 1. **C语言基础知识** 在开始编写俄罗斯方块之前，我们需要掌握C语言的...
C语言实现俄罗斯方块小游戏
12-31
C语言实现俄罗斯方块小游戏的制作代码，具体内容如下 #include #include #include <unistd> #define TTY_PATH /dev/tty #define STTY_ON stty raw -echo -F #define STTY_OFF stty -raw echo -F int map[21][14...
基于linux开发的俄罗斯方块小游戏.rar
12-29
《基于Linux开发的俄罗斯方块小游戏》是一款利用C语言在Linux环境下实现的经典游戏。这款小游戏不仅展示了编程技术在游戏开发中的应用，同时也体现了Linux系统强大的软件开发能力。下面将详细介绍这款小游戏的技术...
用C语言编写一个俄罗斯方块小游戏
weixin_48856218的博客
04-22 636
#include <stdio.h> #include <string.h> #include <stdlib.h> #include <time.h> #include <conio.h> #include <windows.h> #ifdef _MSC_VER #if _MSC_VER <= 1200 #error ？ #else #if _MSC_VER >= 1600 #include &lt
c语言编写的俄罗斯方块小游戏
08-16
该俄罗斯方块小游戏是由c语言编写而成。只要在能运行c程序的编译器上就能运行。希望大家喜欢
C语言游戏编程之俄罗斯方块-CSDN.zip
12-27
本源码是C语言版游戏编程之俄罗斯方块中国象棋源代码，仅供大家面向过程思维的锻炼和互相学习，请勿用于商业手段，给学习留一份净土，其中的不足之处请各位热爱学习的小伙伴留言告知。
设计俄罗斯方块游戏 俄罗斯 C语言编写的俄罗斯方块
05-25
特别精细的俄罗斯方块小游戏设计  熟悉游戏规则很重要，因为这是程序设计的基本要求，也是基本思路。 游戏规则如下：  电脑随机产生4个小方块组成的不同形状的游戏块，从上往下降落。  游戏面板的宽度为12(以小方块的宽度为单位)，高度为22，当一行被12个小方块填满时，此行便会被自动消除。  利用键盘上的左右箭头键可以控制游戏块的左移与右移。  利用键盘上的向上箭头键可以控制游戏块的旋转。  利用键盘上的向下箭头键可以控制游戏块的快速下落。  当游戏块无法下落时，游戏结束。  在屏幕上可以显示将出现的下一个游戏块。
C语言编程实现俄罗斯方块代码
07-18
这是我自己编写的利用C语言实现俄罗斯方块游戏的源代码，简单实用，大家可以下载后自己修改变成自己的源代码
【新手入门】利用SDL库+C语言编写俄罗斯方块小游戏小实践
06-14
基础太差，现在重新学习了一遍C语言。因为训练要求，要学习SDL库的使用，编写个SDL+俄罗斯方块小游戏。转眼一周多，小白终于写出来了。以下是一些体会。感觉还是好好学习，多撸代码才是正道。 借鉴了挺多前辈的经验【纯个人手码】
俄罗斯方块小游戏-C语言实现
houzi07的博客
01-05 299
首次做关于游戏的小项目 一些想法和过程不是很巧妙还有待改良 仅供参考 #include <stdio.h> #include <windows.h> #include <conio.h> #include <time.h> // ●■★▓※ //1 ● //2 ■ #define _HIGH_ 21 #define _WIDTH_ 12 #define _SHAPE_LEN_ 4 void initMap(); //初始背背景图 void printSta
【C语言小游戏】俄罗斯方块
走向CTO的路上...
06-08 848
俄罗斯方块是一款经典的游戏，玩家需要通过控制下落的方块，使其在底部形成完整的一行或多行，已经形成的一行或多行会被消除，游戏难度逐渐加大。
俄罗斯方块
qq_43573663的博客
07-19 563
#include<stdio.h> #include<stdlib.h> #include<windows.h>//Sleep()函数的头文件 #include<time.h> #include<conio.h> #define MOD 28 #define SIZE_N 19//控制边框的高度 #define SIZE_M 12 //控制边框的宽度 int a[100]={200,30,20};//定义排行榜 int cur_x,cu
c语言俄罗斯方块简易
12-21
C语言俄罗斯方块是一个经典的游戏，可以通过使用C语言编写一个简易版本。下面是一个简单的示例代码，演示了如何使用C语言实现俄罗斯方块游戏： ```c #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <windows.h> #define WIDTH 10 #define HEIGHT 20 int field[HEIGHT][WIDTH] = {0}; int shapes[7][4] = { {1, 1, 1, 1}, // I shape {1, 1, 1, 0, 1}, // L shape {1, 1, 1, 0, 0, 1}, // J shape {1, 1, 0, 0, 1, 1}, // Z shape {1, 1, 0, 0, 0, 1, 1}, // S shape {1, 1, 1, 0, 1, 0}, // T shape {0, 1, 1, 0, 1, 1} // O shape }; int rotate(int shape[], int rotation) { int newShape[4] = {0}; int index = 0; for (int i = 0; i < 4; i++) { int x = i % 2; int y = i / 2; int newX = -y; int newY = x; int newIndex = newY * 2 + newX; newShape[newIndex] = shape[i]; } return newShape[rotation % 4]; } int checkCollision(int x, int y, int shape[], int rotation) { for (int i = 0; i < 4; i++) { int newX = x + i % 2; int newY = y + i / 2; int index = newY * WIDTH + newX; if (newX < 0 || newX >= WIDTH || newY >= HEIGHT || (newY >= 0 && field[newY][newX] != 0 && shape[rotate(shape, rotation) * 4 + i] != 0)) { return 1; } } return 0; } void drawField() { system("cls"); for (int y = 0; y < HEIGHT; y++) { for (int x = 0; x < WIDTH; x++) { printf(field[y][x] ? "*" : " "); } printf("\n"); } } void drawShape(int x, int y, int shape[], int rotation) { for (int i = 0; i < 4; i++) { int newX = x + i % 2; int newY = y + i / 2; if (newY >= 0 && shape[rotate(shape, rotation) * 4 + i] != 0) { field[newY][newX] = 1; } } } void clearShape(int x, int y, int shape[], int rotation) { for (int i = 0; i < 4; i++) { int newX = x + i % 2; int newY = y + i / 2; if (newY >= 0 && shape[rotate(shape, rotation) * 4 + i] != 0) { field[newY][newX] = 0; } } } int main() { int x = WIDTH / 2 - 2; int y = 0; int shapeIndex = rand() % 7; int rotation = 0; int gameOver = 0; while (!gameOver) { drawField(); drawShape(x, y, shapes[shapeIndex], rotation); if (kbhit()) { switch (getch()) { case 'a': if (!checkCollision(x - 1, y, shapes[shapeIndex], rotation)) { clearShape(x, y, shapes[shapeIndex], rotation); x--; } break; case 'd': if (!checkCollision(x + 1, y, shapes[shapeIndex], rotation)) { clearShape(x, y, shapes[shapeIndex], rotation); x++; } break; case 's': if (!checkCollision(x, y + 1, shapes[shapeIndex], rotation)) { clearShape(x, y, shapes[shapeIndex], rotation); y++; } break; case 'w': if (!checkCollision(x, y, shapes[shapeIndex], rotation + 1)) { clearShape(x, y, shapes[shapeIndex], rotation); rotation++; } break; case 'q': gameOver = 1; break; } } if (checkCollision(x, y + 1, shapes[shapeIndex], rotation)) { drawShape(x, y, shapes[shapeIndex], rotation); shapeIndex = rand() % 7; rotation = 0; x = WIDTH / 2 - 2; y = 0; if (checkCollision(x, y, shapes[shapeIndex], rotation)) { gameOver = 1; } } else { Sleep(500); clearShape(x, y, shapes[shapeIndex], rotation); y++; } } printf("Game Over!\n"); return 0; } ``` 这段代码使用了Windows.h头文件中的conio.h和windows.h库来实现在Windows命令行中显示游戏界面。你可以将代码复制到一个C文件中，并使用C编译器进行编译和运行。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值