俄罗斯方块游戏及排行榜——c语言

最新推荐文章于 2024-10-05 15:49:52 发布
最新推荐文章于 2024-10-05 15:49:52 发布
阅读量3k 收藏 46
点赞数 5
文章标签： 游戏 c语言 程序设计 小程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51497041/article/details/111018076
版权

一、功能

1.登录，注册账号功能；
2.排行榜维护功能；
3,游戏处理等（这里的代码是从网上下载的，不是原创因为人家写的实在是太牛逼了！佩服！）
4.结束游戏，处理文件；

二、流程图

在这里插入图片描述

三、遇到的疑惑

1.

文件的读取，在文件里存储的字符串可以通过fgets读取，但这种读取是一下子就是一行；然后就是fscanf（“%s”）这种读取是遇到空格便会停止。 我觉得这种的还是挺好的；（个人认为）

2.

switch（）这个函数不是到为啥；

switch(ch)
	{
		case 'W':
		case 'w': 
		case 72:
				d=1;
				
			break;
		case 'S':
		case 's': 
		case 80:
				d=0;
					
			break;
	}

在他外边的的循环中无法第一次，实现对d的值进行修改；直到第二次才能修改成功，这个问题也是快把我整神经了；到现在也是不知道为啥；后来通过system(“cls”)清屏间接解决但会出现闪一下屏的问题；唉！！！！！！奇怪！无奈！

3.

第三个卡我的点便是：文件里有char和int两种类型数据是，不知道能否读取出来，这里其实并不是很难，就是我读取int类型数据时，fscanf（“%d”）写成了fscanf（“%s”），结果编译可以过，但运行时，老是出现崩溃问题，整的我也不知道哪儿错了，还好我又写了一个简短程序专门是读取文件数据的，两个程序一对比才发现这个问题，

4.

第四个便是：我从网上下载的这个代码，其中他输出的得分为零时，在文件里显示的是（null）；但在从文件里输出的时候，0分为空，无法给我的结构体传值，因而无法做排序。人家的是%u，我的int数据为%d，我猜测会是这里的问题！（其他的数倒是都没啥问题）！我解决的办法为，当那个人的0分时不计入排行榜，若已有分数则值计入超过上次成绩的成绩，我发现这样反而让游戏更有意思！

四、完整代码：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <conio.h>
#include <windows.h>
 #include<iostream>
 
#ifdef _MSC_VER // M$的编译器要给予特殊照顾
 #if _MSC_VER <= 1200 // VC6及以下版本
 #error 你是不是还在用VC6？！
 #else // VC6以上版本
 #if _MSC_VER >= 1600 // 据说VC10及以上版本有stdint.h了
  #include <stdint.h>
 #else // VC10以下版本，自己定义int8_t和uint16_t
  typedef signed char int8_t;
  typedef unsigned short uint16_t;
 #endif
 #ifndef __cplusplus // 据说VC都没有stdbool.h，不用C++编译，自己定义bool
  typedef int bool;
  #define true 1
  #define false 0
 #endif
 #endif
#else // 其他的编译器都好说
 #include <stdint.h>
 #ifndef __cplusplus // 不用C++编译，需要stdbool.h里的bool
 #include <stdbool.h>
 #endif
#endif
 
// =============================================================================
// 7种方块的4旋转状态（4位为一行）
static const uint16_t gs_uTetrisTable[7][4] =
{
 { 0x00F0U, 0x2222U, 0x00F0U, 0x2222U }, // I型
 { 0x0072U, 0x0262U, 0x0270U, 0x0232U }, // T型
 { 0x0223U, 0x0074U, 0x0622U, 0x0170U }, // L型
 { 0x0226U, 0x0470U, 0x0322U, 0x0071U }, // J型
 { 0x0063U, 0x0264U, 0x0063U, 0x0264U }, // Z型
 { 0x006CU, 0x0462U, 0x006CU, 0x0462U }, // S型
 { 0x0660U, 0x0660U, 0x0660U, 0x0660U } // O型
};
 
// =============================================================================
// 初始状态的游戏池
// 每个元素表示游戏池的一行，下标大的是游戏池底部
// 两端各置2个1，底部2全置为1，便于进行碰撞检测
// 这样一来游戏池的宽度为12列
// 如果想要传统的10列，只需多填两个1即可（0xE007），当然显示相关部分也要随之改动
// 当某个元素为0xFFFFU时，说明该行已被填满
// 顶部4行用于给方块，不显示出来
// 再除去底部2行，显示出来的游戏池高度为22行
static const uint16_t gs_uInitialTetrisPool[28] =
{
 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U,
 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U,
 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U,
 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xC003U, 0xFFFFU, 0xFFFFU
};
 
#define COL_BEGIN 2
#define COL_END 14
#define ROW_BEGIN 4
#define ROW_END 26
 
// =============================================================================
typedef struct TetrisManager // 这个结构体存储游戏相关数据
{
 uint16_t pool[28]; // 游戏池
 int8_t x; // 当前方块x坐标，此处坐标为方块左上角坐标
 int8_t y; // 当前方块y坐标
 int8_t type[3]; // 当前、下一个和下下一个方块类型
 int8_t orientation[3]; // 当前、下一个和下下一个方块旋转状态
 unsigned score; // 得分
 unsigned erasedCount[4]; // 消行数
 unsigned erasedTotal; // 消行总数
 unsigned tetrisCount[7]; // 各方块数
 unsigned tetrisTotal; // 方块总数
 bool dead; // 挂
} TetrisManager;
 
// =============================================================================
typedef struct TetrisControl // 这个结构体存储控制相关数据
{
 bool pause; // 暂停
 bool clockwise; // 旋转方向：顺时针为true
 int8_t direction; // 移动方向：0向左移动 1向右移动
 // 游戏池内每格的颜色
 // 由于此版本是彩色的，仅用游戏池数据无法存储颜色信息
 // 当然，如果只实现单色版的，就没必要用这个数组了
 int8_t color[28][16];
} TetrisControl;
 
HANDLE g_hConsoleOutput; // 控制台输出句柄
 
// =============================================================================
// 函数声明
// 如果使用全局变量方式实现，就没必要传参了
void initGame(TetrisManager *manager, TetrisControl *control); // 初始化游戏
void restartGame(TetrisManager *manager, TetrisControl *control); // 重新开始游戏
void giveTetris(TetrisManager *manager); // 给一个方块
bool checkCollision(const TetrisManager *manager); // 碰撞检测
void insertTetris(TetrisManager *manager); // 插入方块
void removeTetris(TetrisManager *manager); // 移除方块
void horzMoveTetris(TetrisManager *manager, TetrisControl *control); // 水平移动方块
void moveDownTetris(TetrisManager *manager, TetrisControl *control); // 向下移动方块
void rotateTetris(TetrisManager *manager, TetrisControl *control); // 旋转方块
void dropDownTetris(TetrisManager *manager, TetrisControl *control); // 方块直接落地
bool checkErasing(TetrisManager *manager, TetrisControl *control); // 消行检测
void keydownControl(TetrisManager *manager, TetrisControl *control, int key); // 键按下
void setPoolColor(const TetrisManager *manager, TetrisControl *control); // 设置颜色
void gotoxyWithFullwidth(short x, short y); // 以全角定位
void printPoolBorder(); // 显示游戏池边界
void printTetrisPool(const TetrisManager *manager, const TetrisControl *control); // 显示游戏池
void printCurrentTetris(const TetrisManager *manager, const TetrisControl *control); // 显示当前方块
void printNextTetris(const TetrisManager *manager); // 显示下一个和下下一个方块
void printScore(const TetrisManager *manager); // 显示得分信息
void runGame(TetrisManager *manager, TetrisControl *control); // 运行游戏
void printPrompting(); // 显示提示信息
bool ifPlayAgain(); // 再来一次
 
 
 void wait(int second)
 {
 	clock_t end;
 	end=clock()+second*CLOCKS_PER_SEC;
 	while(clock()<end)
 	{
 		NULL;
	 }
  } 
 
char a[40],b[40];
 
 int chuan;
// =============================================================================                                                       奇   
// 主函数
int main()
{
	FILE *fp,*fq,*p,*q;
	int h,e,i;
	char a[40],b[40];
	char ch;
	typedef struct shuj
	{
		char zhang[40];
		char  mi[40]; 
	} shuj;
	
	typedef struct pai
	{
		char str[40];
		int  stri;
	}pai;
	
	pai lie[100];
	shuj shuju[100];
	char str[100];//字符数组长度
	//创建文件； 
	if((p = fopen("shuju.txt","w")) == NULL)//输入子串字符 
	{
		printf("can not open this file \n");
		exit(0);
	}
	fprintf(p,"gao mima\n") ;
	fprintf(p,"xiu mima\n");
	fprintf(p,"qi mima\n");
	fprintf(p,"guo mima\n");
	fprintf(p,"lin mima");
	fclose(p);
	
	if((q = fopen("paihangbang.txt","w")) == NULL)//输入子串字符 
	{
		printf("can not open this file \n");
		exit(0);
	}
	fprintf(q,"gao 370\n");
	fprintf(q,"xiu 67\n");
	fprintf(q,"qi 40\n");
	fprintf(q,"guo 30\n");
	fprintf(q,"lin 10");
	
	fclose(q);
	if((fq = fopen("shuju.txt","r")) == NULL)//输入子串字符 
	{
		printf("can not open this file \n");
		exit(0);
	}
	h=0;
	while(!feof(fq))//输入账户密码； 
	{
		//printf("%d %d ",h,e);
		fscanf(fq,"%s",shuju[h].zhang);//一个回车 三个字符去存它   会使字符数组增加三个 
		//
		//printf("%s ",shuju[h].zhang);
		fscanf(fq,"%s",shuju[h].mi);
		//printf("%s \n",shuju[h].mi);
		
		h++;
	}
	fclose(fq);
	 
	//============================================================================= 
	int d=2,x=1;
	int z=1; 
	system("color 1c");
	while(d==2) //注册新号 和登录 
	{ 
	
		printf("\n\n\n\n");
		printf("                                 ★俄罗斯方块★\n\n"); 
		printf("                      ■================================■\n\n");
		printf("                                 登录：    按↑\n");
	
		printf("                                 注册：    按↓\n\n");
		printf("                      ■================================■\n");
		
	
	

	ch=getch();//一但超过getch（）的空间就会破坏数组，一般采用fgets 把字符或字符串写入文件 不容易被蠕虫攻击！ 
	
	switch(ch)
	{
		case 'W':
		case 'w': 
		case 72:
				d=1;
				
			break;
		case 'S':
		case 's': 
		case 80:
				d=0;
					
			break;
	}
	
	//printf("%d",d);
	
	if(d==1)//登录
	{
		system("cls");
		while(1)
		{
			
		printf("\n\n");
		printf("                                 ★俄罗斯方块★\n\n"); 
		printf("                      ■================================■\n\n");
		printf("                                 输入账号："); 
		scanf("%s",a) ;//用%s输入时，不能变成a[40] 这样就变成了字符数组； 
		printf("                                 输入密码："); 
		scanf("%s",b);
		
		printf("\n                      ■================================■\n");
		printf("                                 正在加载……"); 
		wait(1);//加时间延迟！ 
		
		for(i=0;i<h;i++)
			if(!strcmp(a,shuju[i].zhang)&&!strcmp(b,shuju[i].mi)) //strcmp找到相同的时返回0 
				break;
		
		if(i<h)
			break;
		else
		{
			printf("\n\n                             输入账号或密码有错误！\n");
			wait(1);
		}
			
		d=1;
		
		system("cls");
		}
	}
		if((fq = fopen("shuju.txt","r+")) == NULL)//输入子串字符 
			{
				printf("can not open this file \n");
				exit(0);
			}
		
		if(d==0)
		while(1)//注册 
		{
			system("cls");
			fseek(fq,0,2);
			
			printf("\n\n");
			printf("                                 ★俄罗斯方块★\n\n"); 
			printf("                      ■================================■\n\n");
			printf("                                 输入新账号："); 
			scanf("%s",a) ;//用%s输入时，不能变成a[40] 这样就变成了字符数组； 
			
			
			for(i=0;i<h;i++)//检测是否有账号已被注册： 
			if(!strcmp(a,shuju[i].zhang)) //strcmp（）存在相同的时返回0； 	
				break;
			 	
			if(i<h)
			{	
				printf("\n                                 账号已存在！\n");
				wait(1);
				system("cls");
				continue ;
			}
			
			if(i>=h)
			{
				printf("                                 设置密码：");
				scanf("%s",b);
				fprintf(fq,"\n%s ",a);
				fprintf(fq,"%s",b);
				printf("                                 注册成功！\n");
				printf("\n                      ■================================■\n");
				printf("                                 正在加载……"); 
				wait(1);
				break;
			}	
			
			
		}
		fclose(fq);
	
		if(d==2)
		{
			
			
			system("cls");
		}
			
			
		if(x==1)		
		{
			system("cls");
			x=0;
		}
		
	}
	//=================================================================
	
	if((fp = fopen("paihangbang.txt","r")) == NULL)//输入子串字符 
	{
		printf("can not open this file \n");
		exit(0);
	}
	h=0;
	
	system("cls");
	
	printf("\n\n                                 ★俄罗斯方块★\n\n"); 
	printf("\n                                     排行榜！\n");
	printf("                      ■================================■\n\n");
	while(!feof(fp))
	{
		//printf("%d %d ",h,e);
		fscanf(fp,"%s",lie[h].str);//一个回车 三个字符去存它   会使字符数组增加三个 
		printf("                                 ");
		printf("第%d名 %s的得分为",h+1,lie[h].str);
	
		fscanf(fp,"%d",&lie[h].stri);
		printf("%d\n",lie[h].stri);
		
		h++;
	}
	fclose(fp);
	printf("                      ■================================■\n");
	printf("\n                                 取得更高分数，击败他们！\n");	
	printf("\n\n                                 即将开始游戏……\n");
	//printf("%d",h); 
	system("pause");//==========系统自己的暂停! 
	system("cls");
	
	//===================================================================================================main========================================== 
	
		TetrisManager tetrisManager;
 		TetrisControl tetrisControl;
 
 
 		initGame(&tetrisManager, &tetrisControl); // 初始化游戏
 
 		do
 		{
 		printPrompting(); // 显示提示信息
 		printPoolBorder(); // 显示游戏池边界
 		runGame(&tetrisManager, &tetrisControl); // 运行游戏
 			if (ifPlayAgain()) // 再来一次
			 {
 		 	SetConsoleTextAttribute(g_hConsoleOutput, 0x7);
  			system("cls"); // 清屏
 			restartGame(&tetrisManager, &tetrisControl); // 重新开始游戏
			 }
		 	else
 			{	
			 	int ww,weixiu=0;
			 	system("cls");
			 	for( ww=0;ww<h;ww++)
			 	{
			 		if(strcmp(lie[ww].str,a)==0)
			 		{
			 			if(lie[ww].stri<chuan)
			 			{
			 				lie[ww].stri=chuan;
			 				weixiu=1;
						 }
			 				
			 			break;
					}
			 		
				 }
				
				 if(ww>=h)//未检测到账号 需要添加数据；  如果的0分则无法登入排行榜； 
				 {
				 	if(chuan>0) 
				 	{
				 		lie[h].stri=chuan;
				 		strcpy(lie[h].str,a);
				 		h++;
					 }
				 	
				 }
			 	
			 	
			 						//排序； 
			 	int yy;
			 	char xx[40];
			 	for(int n=0;n<h-1;n++)
			 		for(int m=n+1;m<h;m++)
					{
						//printf("%s ",lie[n].str);					
						//printf("%d\n",lie[n].stri);
						
				 		if(lie[n].stri<lie[m].stri)
				 		{
				 			yy=lie[n].stri;
				 			strcpy(xx,lie[n].str);
				 			
				 			lie[n].stri=lie[m].stri;
				 			strcpy(lie[n].str,lie[m].str);
				 			
				 			lie[m].stri=yy;
				 			strcpy(lie[m].str,xx);
						 }
				 		
					}
			 	if((fp = fopen("paihangbang.txt","w")) == NULL)//输入子串字符 
				{
					printf("can not open this file \n");
					exit(0);
				}
			//	printf("%d\n",h);
				for(int u=0;u<=h;u++)
				{
					
					//printf("%s ",lie[u].str);
					if(lie[u].stri==0)//这里需要把账号密码shuju文件里的0分的账号删除！ ================= 
						break;
					//printf("%d\n",lie[u].stri);
					
					fprintf(fp,"%s ",lie[u].str);
					fprintf(fp,"%d\n",lie[u].stri);
				}
				
				printf("宝贝儿！回见！"); 
				fclose(fp);
  				break;
 			}
 		}
  		while (1);
  		//puts(lie[h].str);
  		//printf("%d",lie[h].stri);
 		gotoxyWithFullwidth(0, 0);
 		CloseHandle(g_hConsoleOutput);
 	//===================================================	
	
 
 return 0;
}
 
// =============================================================================
// 初始化游戏
void initGame(TetrisManager *manager, TetrisControl *control)
{
 CONSOLE_CURSOR_INFO cursorInfo = { 1, FALSE }; // 光标信息
 
 g_hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE); // 获取控制台输出句柄
 SetConsoleCursorInfo(g_hConsoleOutput, &cursorInfo); // 设置光标隐藏
 SetConsoleTitleA("俄罗斯方块控制台版——By: NEWPLAN");
 
 restartGame(manager, control);
}
 
// =============================================================================
// 重新开始游戏
void restartGame(TetrisManager *manager, TetrisControl *control)
{
 memset(manager, 0, sizeof(TetrisManager)); // 全部置0
 
 // 初始化游戏池
 memcpy(manager->pool, gs_uInitialTetrisPool, sizeof(uint16_t [28]));
 srand((unsigned)time(NULL)); // 设置随机种子
 
 manager->type[1] = rand() % 7; // 下一个
 manager->orientation[1] = rand() & 3;
 
 manager->type[2] = rand() % 7; // 下下一个
 manager->orientation[2] = rand() & 3;
 
 memset(control, 0, sizeof(TetrisControl)); // 全部置0
 
 giveTetris(manager); // 给下一个方块
 setPoolColor(manager, control); // 设置颜色
}
 
// =============================================================================
// 给一个方块
void giveTetris(TetrisManager *manager)
{
 uint16_t tetris;
 
 manager->type[0] = manager->type[1]; // 下一个方块置为当前
 manager->orientation[0] = manager->orientation[1];
 
 manager->type[1] = manager->type[2];// 下下一个置方块为下一个
 manager->orientation[1] = manager->orientation[2];
 
 manager->type[2] = rand() % 7;// 随机生成下下一个方块
 manager->orientation[2] = rand() & 3;
 
 tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]]; // 当前方块
 
 // 设置当前方块y坐标，保证刚给出时只显示方块最下面一行
 // 这种实现使得玩家可以以很快的速度将方块落在不显示出来的顶部4行内
 if (tetris & 0xF000)
 {
 manager->y = 0;
 }
 else
 {
 manager->y = (tetris & 0xFF00) ? 1 : 2;
 }
 manager->x = 6; // 设置当前方块x坐标
 
 if (checkCollision(manager)) // 检测到碰撞
 {
 manager->dead = true; // 标记游戏结束
 }
 else // 未检测到碰撞
 {
 insertTetris(manager); // 将当前方块加入游戏池
 }
 
 ++manager->tetrisTotal; // 方块总数
 ++manager->tetrisCount[manager->type[0]]; // 相应方块数
 
 printNextTetris(manager); // 显示下一个方块
 printScore(manager); // 显示得分信息
}
 
// =============================================================================
// 碰撞检测
bool checkCollision(const TetrisManager *manager)
{
 // 当前方块
 uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];
 uint16_t dest = 0;
 
 // 获取当前方块在游戏池中的区域：
 // 游戏池坐标x y处小方格信息，按低到高存放在16位无符号数中
 dest |= (((manager->pool[manager->y + 0] >> manager->x) << 0x0) & 0x000F);
 dest |= (((manager->pool[manager->y + 1] >> manager->x) << 0x4) & 0x00F0);
 dest |= (((manager->pool[manager->y + 2] >> manager->x) << 0x8) & 0x0F00);
 dest |= (((manager->pool[manager->y + 3] >> manager->x) << 0xC) & 0xF000);
 
 // 若当前方块与目标区域存在重叠（碰撞），则位与的结果不为0
 return ((dest & tetris) != 0);
}
 
// =============================================================================
// 插入方块
void insertTetris(TetrisManager *manager)
{
 // 当前方块
 uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];
 
 // 当前方块每4位取出，位或到游戏池相应位置，即完成插入方块
 manager->pool[manager->y + 0] |= (((tetris >> 0x0) & 0x000F) << manager->x);
 manager->pool[manager->y + 1] |= (((tetris >> 0x4) & 0x000F) << manager->x);
 manager->pool[manager->y + 2] |= (((tetris >> 0x8) & 0x000F) << manager->x);
 manager->pool[manager->y + 3] |= (((tetris >> 0xC) & 0x000F) << manager->x);
}
 
// =============================================================================
// 移除方块
void removeTetris(TetrisManager *manager)
{
 // 当前方块
 uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];
 
 // 当前方块每4位取出，按位取反后位与到游戏池相应位置，即完成移除方块
 manager->pool[manager->y + 0] &= ~(((tetris >> 0x0) & 0x000F) << manager->x);
 manager->pool[manager->y + 1] &= ~(((tetris >> 0x4) & 0x000F) << manager->x);
 manager->pool[manager->y + 2] &= ~(((tetris >> 0x8) & 0x000F) << manager->x);
 manager->pool[manager->y + 3] &= ~(((tetris >> 0xC) & 0x000F) << manager->x);
}
 
// =============================================================================
// 设置颜色
void setPoolColor(const TetrisManager *manager, TetrisControl *control)
{
 // 由于显示游戏池时，先要在游戏池里判断某一方格有方块才显示相应方格的颜色
 // 这里只作设置即可，没必要清除
 // 当移动方块或给一个方块时调用
 
 int8_t i, x, y;
 
 // 当前方块
 uint16_t tetris = gs_uTetrisTable[manager->type[0]][manager->orientation[0]];
 
 for (i = 0; i < 16; ++i)
 {
 y = (i >> 2) + manager->y; // 待设置的列
 if (y > ROW_END) // 超过底部限制
 {
  break;
 }
 x = (i & 3) + manager->x; // 待设置的行
 if ((tetris >> i) & 1) // 检测的到小方格属于当前方块区域
 {
  control->color[y][x] = (manager->type[0] | 8); // 设置颜色
 }
 }
}
 
// =============================================================================
// 旋转方块
void rotateTetris(TetrisManager *manager, TetrisControl *control)
{
 int8_t ori = manager->orientation[0]; // 记录原旋转状态
 
 removeTetris(manager); // 移走当前方块
 
 // 顺/逆时针旋转
 manager->orientation[0] = (control->clockwise) ? ((ori + 1) & 3) : ((ori + 3) & 3);
 
 if (checkCollision(manager)) // 检测到碰撞
 {
 manager->orientation[0] = ori; // 恢复为原旋转状态
 insertTetris(manager); // 放入当前方块。由于状态没改变，不需要设置颜色
 }
 else
 {
 insertTetris(manager); // 放入当前方块
 setPoolColor(manager, control); // 设置颜色
 printCurrentTetris(manager, control); // 显示当前方块
 }
}
 
// =============================================================================
// 水平移动方块
void horzMoveTetris(TetrisManager *manager, TetrisControl *control)
{
 int x = manager->x; // 记录原列位置
 
 removeTetris(manager); // 移走当前方块
 control->direction == 0 ? (--manager->x) : (++manager->x); // 左/右移动
 
 if (checkCollision(manager)) // 检测到碰撞
 {
 manager->x = x; // 恢复为原列位置
 insertTetris(manager); // 放入当前方块。由于位置没改变，不需要设置颜色
 }
 else
 {
 insertTetris(manager); // 放入当前方块
 setPoolColor(manager, control); // 设置颜色
 printCurrentTetris(manager, control); // 显示当前方块
 }
}
 
// =============================================================================
// 向下移动方块
void moveDownTetris(TetrisManager *manager, TetrisControl *control)
{
 int8_t y = manager->y; // 记录原行位置
 
 removeTetris(manager); // 移走当前方块
 ++manager->y; // 向下移动
 
 if (checkCollision(manager)) // 检测到碰撞
 {
 manager->y = y; // 恢复为原行位置
 insertTetris(manager); // 放入当前方块。由于位置没改变，不需要设置颜色
 if (checkErasing(manager, control)) // 检测到消行
 {
  printTetrisPool(manager, control); // 显示游戏池
 }
 }
 else
 {
 insertTetris(manager); // 放入当前方块
 setPoolColor(manager, control); // 设置颜色
 printCurrentTetris(manager, control); // 显示当前方块
 }
}
 
// =============================================================================
// 方块直接落地
void dropDownTetris(TetrisManager *manager, TetrisControl *control)
{
 removeTetris(manager); // 移走当前方块
 for (; manager->y < ROW_END; ++manager->y) // 从上往下
 {
 if (checkCollision(manager)) // 检测到碰撞
 {
  break;
 }
 }
 --manager->y; // 上移一格当然没有碰撞
 
 insertTetris(manager); // 放入当前方块
 setPoolColor(manager, control); // 设置颜色
 
 checkErasing(manager, control); // 检测消行
 printTetrisPool(manager, control); // 显示游戏池
}
 
// =============================================================================
// 消行检测
bool checkErasing(TetrisManager *manager, TetrisControl *control)
{
 static const unsigned scores[5] = { 0, 10, 30, 90, 150 }; // 消行得分
 int8_t count = 0;
 int8_t k = 0, y = manager->y + 3; // 从下往上检测
 
 do
 {
 if (y < ROW_END && manager->pool[y] == 0xFFFFU) // 有效区域内且一行已填满
 {
  ++count;
  // 消除一行方块
  memmove(manager->pool + 1, manager->pool, sizeof(uint16_t) * y);
  // 颜色数组的元素随之移动
  memmove(control->color[1], control->color[0], sizeof(int8_t [16]) * y);
 }
 else
 {
  --y;
  ++k;
 }
 } while (y >= manager->y && k < 4);
 
 manager->erasedTotal += count; // 消行总数
 manager->score += scores[count]; // 得分
 
 if (count > 0)
 {
 ++manager->erasedCount[count - 1]; // 消行
 }
 
 giveTetris(manager); // 给下一个方块
 setPoolColor(manager, control); // 设置颜色
 
 return (count > 0);
}
 
// =============================================================================
// 键按下
void keydownControl(TetrisManager *manager, TetrisControl *control, int key)
{
 if (key == 13) // 暂停/解除暂停
 {
 control->pause = !control->pause;
 }
 
 if (control->pause) // 暂停状态，不作处理
 {
 return;
 }
 
 switch (key)
 {
 case 'w': case 'W': case '8': case 72: // 上
 control->clockwise = true; // 顺时针旋转
 rotateTetris(manager, control); // 旋转方块
 break;
 case 'a': case 'A': case '4': case 75: // 左
 control->direction = 0; // 向左移动
 horzMoveTetris(manager, control); // 水平移动方块
 break;
 case 'd': case 'D': case '6': case 77: // 右
 control->direction = 1; // 向右移动
 horzMoveTetris(manager, control); // 水平移动方块
 break;
 case 's': case 'S': case '2': case 80: // 下
 moveDownTetris(manager, control); // 向下移动方块
 break;
 case ' ': // 直接落地
 dropDownTetris(manager, control);
 break;
 case '0': // 反转
 control->clockwise = false; // 逆时针旋转
 rotateTetris(manager, control); // 旋转方块
 break;
 default:
 break;
 }
}
 
// =============================================================================
// 以全角定位
void gotoxyWithFullwidth(short x, short y)
{
 static COORD cd;
 
 cd.X = (short)(x << 1);
 cd.Y = y;
 SetConsoleCursorPosition(g_hConsoleOutput, cd);
}
 
// =============================================================================
// 显示游戏池边界
void printPoolBorder()
{
 int8_t y;
 
 SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
 for (y = ROW_BEGIN; y < ROW_END; ++y) // 不显示顶部4行和底部2行
 {
 gotoxyWithFullwidth(10, y - 3);
 printf("%2s", "");
 gotoxyWithFullwidth(23, y - 3);
 printf("%2s", "");
 }
 
 gotoxyWithFullwidth(10, y - 3); // 底部边界
 printf("%28s", "");
}
 
// 定位到游戏池中的方格
#define gotoxyInPool(x, y) gotoxyWithFullwidth(x + 9, y - 3)
 
// =============================================================================
// 显示游戏池
void printTetrisPool(const TetrisManager *manager, const TetrisControl *control)
{
 int8_t x, y;
 
 for (y = ROW_BEGIN; y < ROW_END; ++y) // 不显示顶部4行和底部2行
 {
 gotoxyInPool(2, y); // 定点到游戏池中的方格
 for (x = COL_BEGIN; x < COL_END; ++x) // 不显示左右边界
 {
  if ((manager->pool[y] >> x) & 1) // 游戏池该方格有方块
  {
  // 用相应颜色，显示一个实心方块
  SetConsoleTextAttribute(g_hConsoleOutput, control->color[y][x]);
  printf("■");
  }
  else // 没有方块，显示空白
  {
  SetConsoleTextAttribute(g_hConsoleOutput, 0);
  printf("%2s", "");
  }
 }
 }
}
 
// =============================================================================
// 显示当前方块
void printCurrentTetris(const TetrisManager *manager, const TetrisControl *control)
{
 int8_t x, y;
 
 // 显示当前方块是在移动后调用的，为擦去移动前的方块，需要扩展显示区域
 // 由于不可能向上移动，故不需要向下扩展
 y = (manager->y > ROW_BEGIN) ? (manager->y - 1) : ROW_BEGIN; // 向上扩展一格
 for (; y < ROW_END && y < manager->y + 4; ++y)
 {
 x = (manager->x > COL_BEGIN) ? (manager->x - 1) : COL_BEGIN; // 向左扩展一格
 for (; x < COL_END && x < manager->x + 5; ++x) // 向右扩展一格
 {
  gotoxyInPool(x, y); // 定点到游戏池中的方格
  if ((manager->pool[y] >> x) & 1) // 游戏池该方格有方块
  {
  // 用相应颜色，显示一个实心方块
  SetConsoleTextAttribute(g_hConsoleOutput, control->color[y][x]);
  printf("■");
  }
  else // 没有方块，显示空白
  {
  SetConsoleTextAttribute(g_hConsoleOutput, 0);
  printf("%2s", "");
  }
 }
 }
}
 
// =============================================================================
// 显示下一个和下下一个方块
void printNextTetris(const TetrisManager *manager)
{
 int8_t i;
 uint16_t tetris;
 
 // 边框
 SetConsoleTextAttribute(g_hConsoleOutput, 0xF);
 gotoxyWithFullwidth(26, 1);
 printf("┏━━━━┳━━━━┓");
 gotoxyWithFullwidth(26, 2);
 printf("┃%8s┃%8s┃", "", "");
 gotoxyWithFullwidth(26, 3);
 printf("┃%8s┃%8s┃", "", "");
 gotoxyWithFullwidth(26, 4);
 printf("┃%8s┃%8s┃", "", "");
 gotoxyWithFullwidth(26, 5);
 printf("┃%8s┃%8s┃", "", "");
 gotoxyWithFullwidth(26, 6);
 printf("┗━━━━┻━━━━┛");
 
 // 下一个，用相应颜色显示
 tetris = gs_uTetrisTable[manager->type[1]][manager->orientation[1]];
 SetConsoleTextAttribute(g_hConsoleOutput, manager->type[1] | 8);
 for (i = 0; i < 16; ++i)
 {
 gotoxyWithFullwidth((i & 3) + 27, (i >> 2) + 2);
 ((tetris >> i) & 1) ? printf("■") : printf("%2s", "");
 }
 
 // 下下一个，不显示彩色
 tetris = gs_uTetrisTable[manager->type[2]][manager->orientation[2]];
 SetConsoleTextAttribute(g_hConsoleOutput, 8);
 for (i = 0; i < 16; ++i)
 {
 gotoxyWithFullwidth((i & 3) + 32, (i >> 2) + 2);
 ((tetris >> i) & 1) ? printf("■") : printf("%2s", "");
 }
}
 
// =============================================================================
// 显示得分信息
void printScore(const TetrisManager *manager)
{
 static const char *tetrisName = "ITLJZSO";
 int8_t i;
 
 SetConsoleTextAttribute(g_hConsoleOutput, 0xE);
 
 gotoxyWithFullwidth(2, 2);
 printf("■得分：%u", manager->score);
 chuan=manager->score;
 
 gotoxyWithFullwidth(1, 6);
 printf("■消行总数：%u", manager->erasedTotal);
 for (i = 0; i < 4; ++i)
 {
 gotoxyWithFullwidth(2, 8 + i);
 printf("□消%d：%u", i + 1, manager->erasedCount[i]);
 }
 
 gotoxyWithFullwidth(1, 15);
 printf("■方块总数：%u", manager->tetrisTotal);
 
 for (i = 0; i < 7; ++i)
 {
 gotoxyWithFullwidth(2, 17 + i);
 printf("□%c形：%u", tetrisName[i], manager->tetrisCount[i]);
 }
}
 
// =============================================================================
// 显示提示信息
void printPrompting()
{
 SetConsoleTextAttribute(g_hConsoleOutput, 0xB);
 gotoxyWithFullwidth(26, 10);
 printf("■控制：");
 gotoxyWithFullwidth(27, 12);
 printf("□向左移动：← A 4");
 gotoxyWithFullwidth(27, 13);
 printf("□向右移动：→ D 6");
 gotoxyWithFullwidth(27, 14);
 printf("□向下移动：↓ S 2");
 gotoxyWithFullwidth(27, 15);
 printf("□顺时针转：↑ W 8");
 gotoxyWithFullwidth(27, 16);
 printf("□逆时针转：0");
 gotoxyWithFullwidth(27, 17);
 printf("□直接落地：空格");
 gotoxyWithFullwidth(27, 18);
 printf("□暂停游戏：回车");
 gotoxyWithFullwidth(25, 23);
 printf("■By: NEWPLAN @ UESTC");
}
 
// =============================================================================
// 运行游戏
void runGame(TetrisManager *manager, TetrisControl *control)
{
 clock_t clockLast, clockNow;
 
 clockLast = clock(); // 计时
 printTetrisPool(manager, control); // 显示游戏池
 
 while (!manager->dead) // 没挂
 {
 while (_kbhit()) // 有键按下
 {
  keydownControl(manager, control, _getch()); // 处理按键
 }
 
 if (!control->pause) // 未暂停
 {
  clockNow = clock(); // 计时
  // 两次记时的间隔超过0.45秒
  if (clockNow - clockLast > 0.45F * CLOCKS_PER_SEC)
  {
  clockLast = clockNow;
  keydownControl(manager, control, 80); // 方块往下移
  }
 }
 }
}
 
// =============================================================================
// 再来一次
bool ifPlayAgain()
{
 int ch;
 system("cls");
 SetConsoleTextAttribute(g_hConsoleOutput, 0xF0);
 gotoxyWithFullwidth(15, 9);
 printf("游戏结束");
 gotoxyWithFullwidth(14, 11);
 printf("你的分为%d！",chuan);
 gotoxyWithFullwidth(13, 13);
 printf("按Y重玩，按N退出");
 
 
 do
 {
 ch = _getch();
 if (ch == 'Y' || ch == 'y')
 {
  return true;
 }
 else if (ch == 'N' || ch == 'n')
 {
  return false;
 }
 } while (1);
 }
C++实现俄罗斯方块
Monet1的博客
12-07 3783
小游戏
c++ 实现的俄罗斯方块
07-19
用c++ 实现的简单俄罗斯方块代码，适合初学者使用学习的。
俄罗斯方块源代码
一个无聊的程序猿
01-08 1347
目录俄罗斯方块编前准备源代码 俄罗斯方块 你好！欢迎你看到我这篇文章，你玩过俄罗斯方块吗？想用编程编出来吗？？？？？ 编前准备 1.下载编程软件 下载地址：http://xiazai.zol.com.cn/detail/27/263242.shtml 源代码 #include <stdio.h> #include <string.h> #include <stdlib...
C#俄罗斯方块项目实战与源码解析
最新发布
weixin_36178216的博客
10-05 1193
本文还有配套的精品资源，点击获取 简介：本文详细介绍了如何使用C#编程语言来实现俄罗斯方块游戏，提供了完整的游戏设计原理和实现细节，包括游戏循环、对象生成与移动、碰撞检测、行消除以及游戏结束条件等。文章还提供了源码MyELSGame，供学习者深入分析和理解。通过此项目，读者可以学习C#编程和游戏开发的基础知识，并提高编程技能和问题解决能力。 1. C#语言基础和优势 ...
俄罗斯方块c++源代码
热门推荐
panjoel的博客
08-23 3万+
俄罗斯方块 其实这也挺简单 的 #include<iostream> #include<string> #include<ctime> #include<cstdlib> #include<windows.h> #include<conio.h> using namespace std; int block00[4][4]...
俄罗斯方块（c++）
weixin_49324123的博客
10-03 665
#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++语言实现俄罗斯方块
weixin_42611177的博客
02-16 972
俄罗斯方块是一款经典的游戏，使用C语言实现可以考虑以下步骤： 创建游戏框架：可以使用C语言中的窗口库(如SDL或OpenGL)创建一个游戏窗口，以便显示游戏界面。 设计方块：定义俄罗斯方块的形状和颜色，可以使用二维数组表示方块的形状，每一种颜色用一个整数值表示。 控制方块移动：使用键盘输入函数来控制方块的移动、旋转等操作，并对方块进行边界检测，以避免超出游戏界面。 碰撞检测：当方块落到底部...
C语言游戏编程之俄罗斯方块-CSDN.zip
12-27
在本资源中，我们主要探讨的是使用C语言进行游戏编程，具体来说是开发经典游戏——俄罗斯方块。C语言是一种底层、高效的编程语言，通常用于系统编程、嵌入式开发等领域，但同样可以用于创建复杂的游戏。这个项目是...
基于单片机实现的俄罗斯方块游戏.rar
03-13
本项目"基于单片机实现的俄罗斯方块游戏"是利用单片机的强大功能，设计并实现了经典的游戏——俄罗斯方块。以下将详细介绍这个项目涉及的关键知识点。 1. **单片机基础**： - **硬件结构**：单片机由CPU、RAM、ROM...
俄罗斯方块游戏（C语言）
weixin_47712251的博客
03-17 8430
如果needNewBlock为真，说明需要生成新的方块，程序将nextBlock变量的值赋给curBlock，并预先生成下一个方块赋值给nextBlock，然后将needNewBlock标记为假。在每次循环中，先判断是否需要生成新的方块。然后，判断当前方块是否能够向下移动，如果可以就向下移动，否则就将当前方块固定在地图上，更新得分，并检查是否有满行需要消除。同时，每隔一段时间会将方块向下移动，如果方块无法继续向下移动，就将方块放到地图上，检查是否有满行，随机生成下一个方块，如果无法继续生成，就结束游戏。
c语言实现俄罗斯方块
11-22
通过实现以上各个部分，一个完整的C语言版俄罗斯方块游戏就诞生了。在实践中，这不仅是对C语言语法的巩固，更是对算法设计、问题解决能力和编程技巧的提升。无论你是初学者还是经验丰富的开发者，都能从中受益匪浅。
俄罗斯方块游戏(C语言)
04-15
c语言小游戏制作，加强c初学者对语言的理解与应用
俄罗斯方块——C++实现
ling08140814的博客
06-13 884
该程序的实现步骤： 编写菜单 旋转规则、形状类Shape和格局类Board Shape类和Board类的构造函数 绘制方块 绘制方块掉落区外边界 处理方块旋转 方块移动和受阻判定 处理方块掉落及更新格局 堆积块消除条件判断 堆积块下落的实现 总体流程控制 按键捕捉和方块下落的频度控制 重绘堆积块 显示游戏结束+设计得分类 显示得分和在操作区外画方框 提示下一方块形状 添加游戏暂停功能 具体的视频教学链接：https://www.51zxw.net/Show.aspx?cid=717&id=792
C++ 实现俄罗斯方块
12-12
1、安装 ncurses 库 sudo apt-get update sudo apt-get install libncurses5-dev 2、编译程序 编译命令要加上 -l 选项引入 ncurses 库： g++ main.cpp -l ncurses
基于单片机的俄罗斯方块游戏机课程设计报告.doc
11-09
本课程设计报告的主题是“基于单片机的俄罗斯方块游戏机”，这是一项针对电子信息工程技术专业学生的学习项目。通过这个设计，学生将学习和实践单片机原理及其在实际应用中的操作，特别是如何利用单片机技术来实现...
C语言俄罗斯方块游戏
02-08
C语言俄罗斯方块游戏,已在PC,51单片机等平台上移植并完美运行
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值