[2] C语言数组版俄罗斯方块

已于 2023-12-28 10:24:59 修改
阅读量723 收藏 4
点赞数 1
分类专栏： C语言 文章标签： c语言
于 2020-11-05 14:39:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_Mu2000/article/details/105620871
版权

本人qq：1395916710
#废话当头
大家好这是我写的第二次博客，这次我给大家带来的是俄罗斯方块，简易版的。我们可以通过上下左右来控制下落物的状态。因为本人的水平问题导致了一些游戏上的bug。在下面表述的过程中我会给大家一一说明有什么bug。

#涉及函数
所涉及函数与贪吃蛇大致相同这里就不在一一列举。我们在下面说明的过程当中会进行详细的说明。

#如何编写
这里我最初的设想是这样的，我们定义一个整型的二维数组。0代表为空，1代表能够移动的方块，2代表不能够移动的方块。并使用另一个函数来进行地图的刷新。这里我们用for循环进行刷新。

代码奉上

void move(int x,int y)
{
	COORD coord;
	coord.X=x;
	coord.Y=y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord); 
}

这个函数所需要的的头文件是windows，h头文件起到移动光标的作用，这个对我来说不论是贪吃蛇还是俄罗斯方块都是最为重要的一个函数。这个调用了windows自带的api。可以上网自行查阅。

#include<stdio.h>
#include<stdlib.h>
#include<windows.h> 
#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
int map[39][24];
struct Judge//这里我们用M存储mood F用来保存我们一共mood的状态 
{
	int M;
	int F;
}Judge;
struct SD//我们用SD结构体存储每一个方格的位置 
{
	int x;
	int y;
}SD[5];
void right();//向右移动 （完成） 
void down();//方块下降（完成） 
void left();//向左移动（完成） 
void GET();
void mood();//创建模组（完成） 
void move(int x,int y);
void refresh();//刷新地图（完成） 
void original();//初始化游戏（完成） 
void up();//用于旋转mood 
void Judge_H();
int Judge_T(int x);//用于判断某块是否到达底端
int S_map();//简化代码量

void Judge_H()
{
	int x,y,h;
	int Map[40][24];
	for(x=0;x<40;x++)
	{
		for(y=0;y<24;y++)
		{
			Map[x][y]=0;
		}
	}
	for(y=22;y>1;y--)
	{
		h=0;
		for(x=2;x<38;x+=2)
		{
			if(map[x][y]==2)
			{
				h++;	
			}
		}
		if(h>=17)
		{	
			for(x=2;x<38;x++)
			{
				for(y=1;y<23;y++)
				{
					if(map[x][y]==2)
					{
						map[x][y]=0;
						Map[x][y]=2;	
					}
					
				}
			}
			for(x=2;x<38;x++)
			{
				for(y=1;y<23;y++)
				{
					if(Map[x][y]==2)
					{
						map[x][y+1]=2;
					}
				}
			}
		}
	}
}

int S_map()
{
	int x,y,z=0;
	for(x=2;x<38;x+=2)
	{
		for(y=1;y<23;y++)
		{
			if(map[x][y]==1)
			{
				SD[z].x=x;
				SD[z].y=y;
				z++;
			}
		}
	}
	return(z);
 } 

int Judge_T(int x)
{
	int a;
	int y=0;
	move(42,11);
	printf("%d",x);
	for(a=0;a<x;a++)
	{
		/*move(SD[0].x+10,SD[0].y);
		printf("%d %d",SD[0].x,SD[0].y);
		move(SD[1].x+10,SD[1].y);
		printf("%d %d",SD[1].x,SD[1].y);
		move(SD[2].x+10,SD[2].y);
		printf("%d %d",SD[2].x,SD[2].y);
		move(SD[3].x+10,SD[3].y);
		printf("%d %d",SD[3].x,SD[3].y);
		move(SD[4].x+10,SD[4].y);
		printf("%d %d",SD[4].x,SD[4].y);*/
		if(map[SD[a].x][SD[a].y+1]==2)
		{
			y++;
			for(a=0;a<x;a++)
			{			
				map[SD[a].x][SD[a].y]=0;
			}
			for(a=0;a<x;a++)
			{
				map[SD[a].x][SD[a].y]=2;
			}
			Judge.F=0;
			Judge_H();
		    mood();
			break;
		}
	}
	if(y==0)
	{
		return 1;
	}
}

void up()
{
	int z;
	move(43,7);
	printf("%d",Judge.F);
	z=S_map();
		if(Judge_T(z)==1)
		{
			if(Judge.M==1)//完成 
			{
				if(Judge.F==0)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[0].x+2][SD[0].y]=1;
					map[SD[1].x][SD[1].y-1]=1;
					map[SD[2].x-2][SD[2].y]=1;
					Judge.F++;
				}
				else if(Judge.F==1)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[0].x][SD[0].y]=1;
					map[SD[1].x+2][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					Judge.F++;
				}
				else if(Judge.F==2)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[0].x][SD[0].y+1]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					Judge.F++;
				}
				else if(Judge.F==3)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[0].x][SD[0].y]=1;
					map[SD[1].x-2][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					Judge.F=0;
				}
			}
			else if(Judge.M==2)//完成 
			{
				;	
			}
			else if(Judge.M==3)//完成 
			{
				if(Judge.F==0)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[0].x-2][SD[0].y+1]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x+2][SD[2].y-1]=1;
					Judge.F++;
				}
				else if(Judge.F==1)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[0].x+2][SD[0].y-1]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x-2][SD[2].y+1]=1;
					Judge.F=0;
				}
	
			}
			else if(Judge.M==4)//完成 
			{
				if(Judge.F==0)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x+2][SD[0].y-2]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x][SD[3].y-1]=1;
					Judge.F++;
				}
				else if(Judge.F==1)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x-2][SD[0].y+1]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x][SD[3].y]=1;
					Judge.F++;
				}
				else if(Judge.F==2)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x][SD[0].y]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x-2][SD[3].y-1]=1;
					Judge.F++;
				}
				else if(Judge.F==3)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x][SD[0].y+1]=1;
					map[SD[1].x+2][SD[1].y+2]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x][SD[3].y]=1;
					Judge.F=0;
				}
		
			}
			else if(Judge.M==5)//完成 
			{
				if(Judge.F==0)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x-2][SD[0].y+1]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x-2][SD[2].y]=1;
					map[SD[3].x][SD[3].y-1]=1;
					Judge.F++;
				}
				else if(Judge.F==1)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x+2][SD[0].y-1]=1;
					map[SD[1].x][SD[1].y-2]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x-2][SD[3].y+1]=1;
					Judge.F++;
				}
				else if(Judge.F==2)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x-2][SD[0].y+2]=1;
					map[SD[1].x-2][SD[1].y+2]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x][SD[3].y]=1;
					Judge.F++;
				}
				else if(Judge.F==3)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x][SD[0].y]=1;
					map[SD[1].x-2][SD[1].y+1]=1;
					map[SD[2].x-4][SD[2].y]=1;
					map[SD[3].x-2][SD[3].y+1]=1;
					Judge.F=0;
				}
			
	
			}
			else if(Judge.M==6)//完成 
			{
				;
			}
			else if(Judge.M==7)//完成 
			{
				if(Judge.F==0)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x+4][SD[0].y]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x][SD[2].y]=1;
					map[SD[3].x][SD[3].y-2]=1;
					Judge.F++;
				}
				else if(Judge.F==1)
				{
					map[SD[0].x][SD[0].y]=0;
					map[SD[1].x][SD[1].y]=0;
					map[SD[2].x][SD[2].y]=0;
					map[SD[3].x][SD[3].y]=0;
					map[SD[0].x][SD[0].y]=1;
					map[SD[1].x][SD[1].y]=1;
					map[SD[2].x][SD[2].y+2]=1;
					map[SD[3].x-4][SD[3].y]=1;
					Judge.F=0;
				}
	
			}
			else if(Judge.M==8)//完成 
			{
				;
			}
			else//完成 
			{
				;
			}		
		}	
}
void move(int x,int y)
{
	COORD coord;
	coord.X=x;
	coord.Y=y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord); 
}

void GET()
{
	int Fx;
	while(1)
	{
			Fx=getch(); 
			switch(Fx)
			{
				case UP:
					{
						up();
						refresh();
						while(1)
						{
							if(kbhit()==0)
							{
								refresh();
								down();
							}
							if(kbhit()!=0)
							{
								break;
							} 
						}
						
						break;
					}
				case DOWN:
					{
						while(1)
						{
							if(kbhit()==0)
							{
								refresh();
								down();
							}
							if(kbhit()!=0)
							{
								break;
							} 
						}
						break;
					}
				case RIGHT:
					{
						right();
						refresh();
						while(1)
						{
							if(kbhit()==0)
							{
								down();
								refresh();
							}
							if(kbhit()!=0)
							{
								break;
							} 
						}
						break;
					}
				case LEFT:
					{
						left();
						refresh();
						while(1)
						{
							if(kbhit()==0)
							{
								down();
								refresh();
							}
							if(kbhit()!=0)
							{
								break;
							} 
						}
						break;
					}
			}
			}		
			
}

void right()
{
	int x,z,y=0;
	z=S_map();
	for(x=0;x<z;x++)
	{
		if((SD[x].x+2)==38)
		{
			y++;
		}
	}
	for(x=0;x<z;x++)
		{
			map[SD[x].x][SD[x].y]=0;
		}
	if(y==0)
	{
		for(x=0;x<z;x++)
		{
			map[SD[x].x+2][SD[x].y]=1;
		}
	}
	else if(y>=1)
	{
		for(x=0;x<z;x++)
		{
			map[SD[x].x][SD[x].y]=1;
		}
	}
}

void left()
{
	int x,z,y=0;
	z=S_map();
	for(x=0;x<z;x++)
	{
		if((SD[x].x-2)==0)
		{
			y++;
		}
	}
	for(x=0;x<z;x++)
		{
			map[SD[x].x][SD[x].y]=0;
		}
	if(y==0)
	{
		for(x=0;x<z;x++)
		{
			map[SD[x].x-2][SD[x].y]=1;
		}
	}
	else if(y>=1)
	{
		for(x=0;x<z;x++)
		{
			map[SD[x].x][SD[x].y]=1;
		}
	}
}

void mood()
{	
	Judge.M=rand()%(11-0+1)+0;
	if(Judge.M==1)
	{
       map[4][1]=1;
	   map[4][2]=1;
	   map[6][2]=1;	
	}
    else if(Judge.M==2)
    {
    	map[6][1]=1;
	}
	else if(Judge.M==3)
	{
		map[6][1]=1;
	    map[6][2]=1;
	    map[6][3]=1;
	}
	else if(Judge.M==4)
	{
		map[20][1]=1;
	    map[18][2]=1;
	    map[20][2]=1;
	    map[22][2]=1;
	}
	else if(Judge.M==5)
	{
		map[18][1]=1;
		map[18][2]=1;
		map[18][3]=1;
		map[20][3]=1;
	}
	else if(Judge.M==6)
	{
		map[18][1]=1;
		map[18][2]=1;
		map[20][1]=1;
		map[20][2]=1;
	}
	else if(Judge.M==7)
	{
		map[18][1]=1;
		map[20][1]=1;
		map[20][2]=1;
		map[22][2]=1;
	}
	else if(Judge.M==8)
	{
		map[14][1]=1;
		map[14][2]=1;
		map[14][3]=1;
		map[12][2]=1;
		map[16][2]=1;
	}
	else
	{
		map[14][1]=1;
		map[16][1]=1;
	}
}


void refresh()
{
	int x,y;
	for(x=0;x<40;x+=2)
	{
		for(y=0;y<24;y++)
		{
			if(map[x][y]==2||map[x][y]==1)
			{
				move(x,y);
				printf("■");
			}
			else
			{
				move(x,y);
				printf("  ");
			}
		}
	}
}

void original()
{
	int x,y,z;
	for(x=0;x<40;x+=2)
	{
		for(y=0;y<24;y++)
		{
			map[x][y]=0;
		}
	}
	for(x=0;x<38;x+=2)
	{
		y=0;

		map[x][y]=2;

	}
	for(y=0;y<24;y++)
	{

		map[x][y]=2;

	}
	for(;x>0;x-=2)
	{

		map[x][y-1]=2;

	}
	for(;y>0;y-=1)
	{

		map[x][y]=2;

	}
	Judge.F=0;
}

void down()
{
	int x,y,z=0;
	z=S_map();
	if(Judge_T(z)==1)
	{
		for(x=0;x<z;x++)
		{
			map[SD[x].x][SD[x].y]=0;
		}
		for(x=0;x<z;x++)
		{
			map[SD[x].x][SD[x].y+1]=1;
		}
	}
	//Sleep(0.1);
}
int main()
{
	int Fx;
	original();
	mood();
	move(43,5);
	printf("%d",Judge.M);
	GET();
}
L_Mu2000
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
二维数组俄罗斯方块
05-18
用二维数组完成的一个俄罗斯方块小游戏。适合初学，以及对二维数组的理解
俄罗斯方块（C语言版） 俄罗斯方块
01-24
【俄罗斯方块（C语言版） 俄罗斯方块】是一个基于C语言实现的经典游戏项目，它将编程技术与游戏设计巧妙结合，展示了C语言在创建交互式程序方面的潜力。在这个项目中，开发者利用C语言的基本结构，如循环、条件语句...
C语言俄罗斯方块（简易版）
ZXL工作室
05-08 7744
本俄罗斯方块全部用绘图函数实现方块的绘制，没有一点资源，因此源代码很小巧，整个程序编译链接好，也就10K多吧。非常小巧的俄罗斯方块。 设计思想： 1、将游戏区域划分为18行*10列的棋盘，设立一个布尔型的二维数组变量，以表示棋盘上各个地方是否有方块。 2、用4个顶点代表各种不同形状的方块，一旦方块在游戏区域中，就把对应的布尔型二维数组变量置为真，表示该方格已经有方块了。 3、如
C语言 实现俄罗斯方块
最新发布
m0_66464341的博客
06-12 109
【代码】C语言 实现俄罗斯方块。
Swift游戏开发之俄罗斯方块：No.3 二维数组
weixin_33878457的博客
01-28 338
数组是一个很有用的数据结构，很多程序都建立在数组之上，我很少看到哪个应用程序不用到数组的。 而我们的俄罗斯方块显然也需要数组，而且是更为特殊的 二维数组。 为什么是二维数组呢？其实我们的整个游戏区域，可以看做是一个二维数组区域，就像这样： 我们的每一个block都占据在这样一个20x10的区域之内，20行，10列的一个200个block的二维数组让...
11 - 小练习（俄罗斯方块，C语言数组写法）
m0_62294345的博客
04-06 3623
俄罗斯方块项目 1.分文件的创建 game.h game.c main.c 2.游戏主体编辑 1. main.c模块 #define _CRT_SECURE_NO_WARNINGS 1 #include"Game.h" void main() { srand((unsigned)time(NULL)); GmaeLoop(); } 2. game.h模块 #pragma once #include<stdio.h> #include<conio.h> //改变光标的头文
俄罗斯方块练习数组
ruiqi317的专栏
11-10 1085
学完c了，总算是有点收获了，自己写了个俄罗斯方块练习数组，在vc6.0控制台环境下编译通过. makehead.h int Makepanel(char Ary_Panel[][10]); void gotoxy(int x, int y); void BrushsScreen(char ary[][20]); int initializationShape(); void ShowS
大学生C++大作业----俄罗斯方块(数组原始方法手搓)
lkjuo的博客
05-14 1905
大学生C++大作业----俄罗斯方块(数组原始方法手搓)原理: 可以理解为掏出两个本子，两支笔和两块橡皮来实现我们的目标。一个本子上读写和更改数组，而我们通过读取这个本子上的数组信息，在另一个本子上对应的位置输出“ ”代表无，“■”代表方块。 并且通过第一个本子上的信息来进行判断，诸如方块的下落，旋转，消除，左右平移等等。 实际：创建一个背景矩阵用于存储0，1. " 0"为空白，“1”为存在静止方块。并通过对背景矩阵结合正在下落的新建方块对应矩阵的判断来进行操作。
C语言控制台彩色俄罗斯方块.zip
01-15
《C语言实现控制台彩色俄罗斯方块》 在编程领域，C语言因其高效、灵活的特点，常被用于开发各种小型游戏，包括经典游戏——俄罗斯方块。本项目“C语言控制台彩色俄罗斯方块”就是一个典型的例子，它利用C语言在...
基于c语言实现的俄罗斯方块
05-11
【基于C语言实现的俄罗斯方块】是一款经典的编程实践项目，它将计算机科学的基本概念与游戏开发相结合，为初学者提供了深入理解C语言和程序设计的机会。该项目涉及到的知识点广泛，包括基本的数据结构、控制流、函数...
C语言版本的俄罗斯方块
03-14
【标题】"C语言版本的俄罗斯方块"是一款基于C语言编程实现的经典游戏，它展示了C语言在游戏开发中的应用。对于初学者来说，通过学习和理解这个项目，可以加深对C语言的理解，掌握基本的控制台编程技巧，以及如何构建...
vb二维数组实现俄罗斯方块
07-27
用二维数组实现俄罗斯方块的好处在于旋转时不必分类讨论方块的类型和旋转前的形态，直接通过坐标运算即可。同时二维数组可以使方块的移动也变得简单。不过缺点在于可能占用很多资源，希望有高手前来指教。
java俄罗斯方块代码（2维数组版）
05-25
代码，2维数组实现方块，代码有点乱，望理解
j2me 俄罗斯方块 数组版
11-01
使用数组维护俄罗斯方块,j2me小游戏. 还有一些不完美的地方.自己使用时候可能会发现
用C语言实现俄罗斯方块（终极版）
12-29
俄罗斯方块终极版终于来了，彩色的和谐，期待着其他游戏的诞生吧！
俄罗斯方块[Flash8源码+简单文档]
11-12
俄罗斯方块游戏Flash版本，内有源码和简单设计文档。在传统的俄罗斯方块的基础上，设计了方块的一些特殊属性，如不可变形、隐身等，增加了游戏难度的同时也增加了游戏趣味。 难点可参考：http://blog.csdn.net/hbuxiaoshe/archive/2010/11/12/6005203.aspx
c语言实现俄罗斯方块小游戏
05-13
总结，实现C语言版的俄罗斯方块需要对C语言有深入理解，以及熟悉图形界面库的使用。这是一个很好的实践项目，可以帮助你巩固编程技能，并理解游戏开发的基本流程。在编写代码的过程中，你将遇到各种挑战，如逻辑处理...
俄罗斯方块（C语言实现）
热门推荐
2021dragon的博客
08-14 17万+
文章目录游戏说明游戏效果展示游戏代码游戏代码详解游戏框架构建隐藏光标光标跳转初始化界面初始化方块信息颜色设置画出方块空格覆盖合法性判断游戏主体逻辑函数判断得分与结束主函数 游戏说明 俄罗斯方块相信大家都知道，这里就不再介绍什么游戏背景了，我这里对本代码实现的俄罗斯方块作一些说明： 按方向键的左右键可实现方块的左右移动。 按方向键的下键可实现方块的加速下落。 按空格键可实现方块的顺时针旋转。 按Esc键可退出游戏。 按S键可暂停游戏，暂停游戏后按任意键继续游戏。 按R键可重新开始游戏。 除此之外，本游戏还
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值