C#实现俄罗斯方块的基本功能

最新推荐文章于 2018-07-20 11:05:40 发布
最新推荐文章于 2018-07-20 11:05:40 发布
阅读量1k 收藏 5
点赞数
分类专栏： C# 文章标签： C# 小游戏 俄罗斯方块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010655942/article/details/17843685
版权 
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace 俄罗斯方块
{
	public partial class MainForm : Form
	{
		public MainForm()
		{
			InitializeComponent();
		}
		PictureBox pb;
		const int w = 10;
		const int h = 20;
		const int a = 40;
		int speed = 400;
		int marks = 0;
		bool gameoverflag = false;
		int[,] p = new int[w, h];
		int[,] c = new int[w, h];
		int[,] c_old = new int[w, h];
		Timer timer;
		
		void MainForm_Load(object sender, EventArgs e)
		{
			this.StartPosition = FormStartPosition.CenterScreen;
			this.AutoSize = true;
			this.MaximizeBox = false;
			this.FormBorderStyle = FormBorderStyle.FixedSingle;
			pb = new PictureBox();
			pb.Margin = new Padding(0, 0, 0, 0);
			pb.Width = w * a;
			pb.Height = h * a;
			pb.Location = new Point(0, 0);
			pb.BackColor = Color.LightGray;
			this.Controls.Add(pb);
			this.KeyDown += new KeyEventHandler(MainForm_KeyDown);
			this.KeyUp += new KeyEventHandler(MainForm_KeyUp);
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					p[i, j] = 0;
				}
			}
			c = make_diamond(0);
			c_old = make_emptydiamond();
			timer = new Timer();
			timer.Interval = speed;
			timer.Tick += new EventHandler(timer_Tick);
			draw();
		}

		void timer_Tick(object sender, EventArgs e)
		{
			if(isequal(c, c_old))
			{
				p = add_p_c(c);
				int[] l_temp = detect_fullline();
				int lines = 0;
				for(int i = 0; i < h; i++)
				{
					if(l_temp[i] == 1)
					{
						lines++;
					}
				}
				marks += lines * lines;
				p = clear_fullline();
				if(isgameover())
				{
					timer.Enabled = false;
					gameoverflag = true;
					MessageBox.Show("Game Over!");
					return;
				}
				c = make_diamond(0);
				c_old = make_emptydiamond();
			}
			else if(isequal(c, move_down()))
			{
				c_old = c;
			}
			else if(!isequal(c, move_down()))
			{
				c = move_down();
			}
			draw();
			this.Text = "俄罗斯方块 得分：" + marks.ToString();
		}

		int[,] make_diamond(int n)
		{
			int[,] c_temp = new int[w, h];
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					c_temp[i, j] = 0;
				}
			}
			switch (n)
			{
				case 0:
					int seed = (int)DateTime.Now.Millisecond;
					Random rd = new Random(seed);
					return make_diamond(rd.Next(1, 25));
				case 1:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[0, 2] = 1;
					c_temp[0, 3] = 1;
					break;
				case 2:
					c_temp[0, 0] = 1;
					c_temp[1, 0] = 1;
					c_temp[2, 0] = 1;
					c_temp[3, 0] = 1;
					break;
				case 3:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 1] = 1;
					c_temp[1, 2] = 1;
					break;
				case 4:
					c_temp[1, 0] = 1;
					c_temp[2, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 1] = 1;
					break;
				case 5:
					c_temp[0, 1] = 1;
					c_temp[0, 2] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					break;
				case 6:
					c_temp[0, 0] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					c_temp[2, 1] = 1;
					break;
				case 7:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[0, 2] = 1;
					c_temp[1, 1] = 1;
					break;
				case 8:
					c_temp[0, 0] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					c_temp[2, 0] = 1;
					break;
				case 9:
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					c_temp[1, 2] = 1;
					break;
				case 10:
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					c_temp[2, 1] = 1;
					break;
				case 11:
					c_temp[0, 0] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					c_temp[1, 2] = 1;
					break;
				case 12:
					c_temp[0, 1] = 1;
					c_temp[1, 1] = 1;
					c_temp[2, 0] = 1;
					c_temp[2, 1] = 1;
					break;
				case 13:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[0, 2] = 1;
					c_temp[1, 2] = 1;
					break;
				case 14:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[2, 0] = 1;
					break;
				case 15:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[0, 2] = 1;
					c_temp[1, 0] = 1;
					break;
				case 16:
					c_temp[0, 0] = 1;
					c_temp[1, 0] = 1;
					c_temp[2, 0] = 1;
					c_temp[2, 1] = 1;
					break;
				case 17:
					c_temp[0, 2] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					c_temp[1, 2] = 1;
					break;
				case 18:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 1] = 1;
					c_temp[2, 1] = 1;
					break;
				case 19:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					break;
				case 20:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					break;
				case 21:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					break;
				case 22:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[1, 0] = 1;
					c_temp[1, 1] = 1;
					break;
				case 23:
					c_temp[0, 0] = 1;
					c_temp[0, 1] = 1;
					c_temp[0, 2] = 1;
					c_temp[0, 3] = 1;
					break;
				case 24:
					c_temp[0, 0] = 1;
					c_temp[1, 0] = 1;
					c_temp[2, 0] = 1;
					c_temp[3, 0] = 1;
					break;
			}
			return c_temp;
		}
		
		int[,] add_p_c(int[,] c_temp)
		{
			int[,] p_temp = new int[w, h];
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					p_temp[i, j] = p[i, j] + c_temp[i, j];
				}
			}
			return p_temp;
		}
		
		int[] detect_border()
		{
			int i_min = w;
			int i_max = -1;
			int j_min = h;
			int j_max = -1;
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					if(c[i, j] != 0)
					{
						i_min = i;
						break;
					}
				}
				if(i_min != w)
				{
					break;
				}
			}
			for(int i = w - 1; i >= 0; i--)
			{
				for(int j = 0; j < h; j++)
				{
					if(c[i, j] != 0)
					{
						i_max = i;
						break;
					}
				}
				if(i_max != -1)
				{
					break;
				}
			}
			for(int j = 0; j < h; j++)
			{
				for(int i = 0; i < w; i++)
				{
					if(c[i, j] != 0)
					{
						j_min = j;
						break;
					}
				}
				if(j_min != h)
				{
					break;
				}
			}
			for(int j = h - 1; j >= 0; j--)
			{
				for(int i = 0; i < w; i++)
				{
					if(c[i, j] != 0)
					{
						j_max = j;
						break;
					}
				}
				if(j_max != -1)
				{
					break;
				}
			}
			int[] border = {j_min, j_max, i_min, i_max};//上下左右边界
			return border;
		}
		
		bool overlap(int[,] c_temp)
		{
			bool bl = false;
			int[,] p_temp = add_p_c(c_temp);
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					if(p_temp[i, j] > 1)
					{
						return true;
					}
				}
			}
			return bl;
		}
		
		int[,] make_emptydiamond()
		{
			int[,] c_temp = new int[w, h];
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					c_temp[i, j] = 0;
				}
			}
			return c_temp;
		}
		
		bool isempty(int[,] c_temp)
		{
			bool bl = true;
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					if(c_temp[i, j] > 0)
					{
						return false;
					}
				}
			}	
			return bl;
		}
		
		bool isequal(int[,] c1, int[,] c2)
		{
			bool bl = true;
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					if(c1[i, j] != c2[i, j])
					{
						return false;
					}
				}
			}
			return bl;
		}
		
		int[] detect_fullline()
		{
			int[] l = new int[h];
			for(int i = 0; i < h; i++)
			{
				l[i] = 1;
			}
			for(int j = 0; j < h; j ++)
			{
				for(int i = 0; i < w; i++)
				{
					if(p[i, j] == 0)
					{
						l[j] = 0;
						break;
					}
				}
			}
			return l;
		}
		
		int[,] clear_fullline()
		{
			int[,] p_temp = make_emptydiamond();
			int flag = h - 1;
			int[] l = detect_fullline();
			for(int i = h - 1; i >= 0; i--)
			{
				if(l[i] == 0)
				{
					for(int j = 0; j < w; j++)
					{
						p_temp[j, flag] = p[j, i];
					}
					flag--;
				}
			}
			return p_temp;
		}
		
		bool isgameover()
		{
			bool bl = false;
			for(int i = 0; i < w; i++)
			{
				if(p[i, 0] > 0)
				{
					return true;
				}
			}
			return bl;
		}
		
		int[,] turn()
		{
			int[,] c_temp = make_emptydiamond();
			int[] border_temp = detect_border();
			int u = border_temp[0];
			int d = border_temp[1];
			int l = border_temp[2];
			int r = border_temp[3];
			if(!(w - 1 - l < d - u || h - 1 - u < r - l))
			{
				if(r - l == 1 && d - u == 1)
				{
					return c;
				}
				else if(r - l == 3)
				{
					c_temp[l, u] = c[l, u];
					c_temp[l, u + 1] = c[l + 1, u];
					c_temp[l, u + 2] = c[l + 2, u];
					c_temp[l, u + 3] = c[l + 3, u];
				}
				else if(d - u == 3)
				{
					c_temp[l, u] = c[l, u];
					c_temp[l + 1, u] = c[l, u + 1];
					c_temp[l + 2, u] = c[l, u + 2];
					c_temp[l + 3, u] = c[l, u + 3];
				}
				else if(r - l == 2)
				{
					c_temp[l, u] = c[l, u + 1];
					c_temp[l + 1, u] = c[l, u];
					c_temp[l, u + 1] = c[l + 1, u + 1];
					c_temp[l + 1, u + 1] = c[l + 1, u];
					c_temp[l, u + 2] = c[l + 2, u + 1];
					c_temp[l + 1, u + 2] = c[l + 2, u];
				}
				else if(d - u == 2)
				{
					c_temp[l, u] = c[l, u + 2];
					c_temp[l + 1, u] = c[l, u + 1];
					c_temp[l + 2, u] = c[l, u];
					c_temp[l, u + 1] = c[l + 1, u + 2];
					c_temp[l + 1, u + 1] = c[l + 1, u + 1];
					c_temp[l + 2, u + 1] = c[l + 1, u];
				}
			}
			if(overlap(c_temp) || isempty(c_temp))
			{
				return c;
			}
			return c_temp;
		}
		
		int[,] move_down()
		{
			int[,] c_temp = make_emptydiamond();
			if(!(detect_border()[1] == h - 1))
			{
				for (int i = 0; i < w; i++)
                {
                    for (int j = 1; j < h; j++)
                    {
                        c_temp[i, j] = c[i, j - 1];
                    }
                }
			}
			if(overlap(c_temp) || isempty(c_temp))
			{
				return c;
			}
			return c_temp;
		}
		
		int[,] move_left()
		{
			int[,] c_temp = make_emptydiamond();
			if(!(detect_border()[2] == 0))
			{
				for (int j = 0; j < h; j++)
                {
                    for (int i = 0; i < w - 1; i++)
                    {
                        c_temp[i, j] = c[i + 1, j];
                    }
                }
			}
			if(overlap(c_temp) || isempty(c_temp))
			{
				return c;
			}
			return c_temp;
		}
		
		int[,] move_right()
		{
			int[,] c_temp = make_emptydiamond();
			if(!(detect_border()[3] == w - 1))
			{
				for (int j = 0; j < h; j++)
                {
                    for (int i = 1; i < w; i++)
                    {
                        c_temp[i, j] = c[i - 1, j];
                    }
                }
			}
			if(overlap(c_temp) || isempty(c_temp))
			{
				return c;
			}
			return c_temp;
		}
		
		void draw()
		{
			int[,] p_temp = add_p_c(c);
			Bitmap bmp = new Bitmap(pb.Width, pb.Height);
			Graphics g = Graphics.FromImage(bmp);
			g.FillRectangle(new SolidBrush(pb.BackColor), new Rectangle(0, 0, pb.Width, pb.Height));
			for(int i = 1; i < w; i++)
			{
				g.DrawLine(new Pen(Color.Black, 1), i * a, 0, i * a, h * a);
			}
			for(int j = 1; j < h; j++)
			{
				g.DrawLine(new Pen(Color.Black, 1), 0, j * a, w * a, j * a);
			}
			for(int i = 0; i < w; i++)
			{
				for(int j = 0; j < h; j++)
				{
					switch(p_temp[i, j])
					{
						case 1:
							g.FillRectangle(new SolidBrush(Color.Black), new Rectangle(a * i, a * j, a, a));
							break;
						default:
							break;
					}
				}
			}
			pb.Image = bmp;
			GC.Collect();
		}
		
		void MainForm_KeyDown(object sender, KeyEventArgs e)
		{
			if(gameoverflag)
			{
				return;
			}
			switch (e.KeyData)
			{
				case Keys.W:
					c = turn();
					break;
				case Keys.Up:
					c = turn();
					break;
				case Keys.S:
					timer.Interval = speed / 10;
					break;
				case Keys.Down:
					timer.Interval = speed / 10;
					break;
				case Keys.A:
					c = move_left();
					break;
				case Keys.Left:
					c = move_left();
					break;
				case Keys.D:
					c = move_right();
					break;
				case Keys.Right:
					c = move_right();
					break;
				case Keys.Space:
					timer.Enabled = timer.Enabled == false ? true : false;
					break;
				default:
					break;
			}
			draw();
		}
		
		void MainForm_KeyUp(object sender, KeyEventArgs e)
		{
			if(e.KeyData == Keys.S || e.KeyData == Keys.Down)
			{
				timer.Interval = speed;
			}
		}
	}
}


很短点的一段代码，实现了俄罗斯方块的基本功能，可以很方便的修改和扩展。

 

717606641
关注
专栏目录
C#实现俄罗斯方块基本功能
08-19
主要为大家详细介绍了C#实现俄罗斯方块的基本功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
俄罗斯方块全功能简化版
零千刻的博客
06-08 2217
初写博客，格式全不知，探索中—— 高手请多指教，新手请多交流。 俄罗斯方块，核心代码源于网络，增加了关卡，分数，最高分数记录等功能。 界面如下图： 核心代码是通过一个三维数组， int block[7][4][2] {     1,1, 1,2, 1,3, 1,4,     1,1, 1,2, 1,3, 2,3,     2,1, 2,2, 1,3, 2,3,
C#面向对象俄罗斯方块
08-15
C#做的俄罗斯方块。采用了面向对象的思想。
俄罗斯方块（C语言版） 俄罗斯方块
01-24
C语言版本的俄罗斯方块，实现了俄罗斯方块的基本功能。
C#面向对象编程俄罗斯方块(代码较简)
09-29
能完成俄罗斯方块的基本玩法，学习了面向对象编程，所以就想用这个思想来完成这个虽普通却能用面向对象编程做出来的，由于花的时间较少，bug多多，大家可以对本项目代码直接进行修改，也可以提高大家的能力
C#实现俄罗斯方块游戏代码
最新发布
02-29
总结来说，"C#实现俄罗斯方块游戏代码"项目涵盖了以下知识点： 1. C#基础语法和面向对象编程 2. Windows Forms应用程序开发 3. GDI+图形绘制技术 4. 游戏逻辑设计与实现，包括方块的生成、旋转、移动和消除 5. 用户...
基于C# Unity实现俄罗斯方块游戏【100012704】
06-12
在Unity中实现俄罗斯方块，首先需要创建一个游戏界面，包括UI面板的切换管理。这通常涉及UI系统，包括Canvas、Panel、Button等元素的使用，以及EventSystem的配置，确保用户交互正常进行。UI面板切换可以通过脚本...
c#实现的俄罗斯方块小游戏
04-03
该俄罗斯方块小游戏已经实现了所有基本功能，玩家可以通过键盘上的上、下、左、右箭头键来控制方块的移动和旋转。游戏的核心机制包括方块的生成、下落、碰撞检测、消除行以及得分计算等。游戏界面简洁，易于操作，...
俄罗斯方块，用C#语言写的，使用面向对象的编程方法
05-02
俄罗斯方块，用C#语言写的，使用面向对象的编程方法
俄罗斯方块面向对象版
09-19
俄罗斯方块面向对象版，采用一些设计模式，比如工厂模式，多态，单实例类等等，实现面向对象的俄罗斯方块。
C#写的简单俄罗斯方块游戏
04-05
用C#写的窗体俄罗斯方块小游戏，主要用二维数组的形式实现。
俄罗斯方块 有计分
01-13
俄罗斯方块 本人学C#也只是2个月的时间而已 里面不需要太多的控件 只有两个LABLE用来计分的而已
俄罗斯方块项目(c#)第三天
种子长眠与尘埃
07-20 1080
刚才写了好多好多，特别有感觉的时候，结果没有保存，全没了，哇，难受的要命。  好了言归正传，今天是第三天了，今天来来实现，方块类：GameBlock，说以下这个类的功能吧： 1.这个类描述了俄罗斯方块中的下落方块的属性，首先对于下落的方块有X坐标，Y坐标，方块的宽度Width，方块的高度Height，下落的速度speed，形状BlockDeformation，颜色Color，最最重要的还需要一...
C#俄罗斯方块窗体里的键盘控制问题
iteye_5183的博客
03-27 291
游戏窗体里有个screenPanel，用来显示方块，后又添加了两个暂停和退出的按钮。现在问题是从另一个主菜单界面点击进入游戏界面后，键盘（wasd）可以控制方块的移动，但只要一点击按钮暂停、再开始，就不能继续使用键盘了，只有退出游戏，重新再开始才行，请问要怎么解决？本人小白，求清楚解答...
c#实现简单的俄罗斯方块
c_living的博客
04-05 1万+
      由于最近刚进出c#，想快速上手，所以决定写几个小游戏（后面会陆续更新）来熟悉语言，并且记录学习winform的一些相关问题和解决方法。      首先给我的感觉winform和c++中的界面设计MFC还是非常类似的（很可惜当时MFC深入浅出没吃透彻），下面我们就从最基础简单的来实现俄罗斯方块：1首先弄出一个窗体：我是在pictureBox控件上面实现画图的（因为没找到图片资源，所以我的...
C#程序设计分析之俄罗斯方块
u011453312的专栏
05-25 1569
前言：            设计俄罗斯方块程序非常考验程序设计能力，也是学习编程的一个非常好的实践案例。能用设计出这个程序说明对C#语法的掌握基本没有问题了，但是不一定就说明编程能力就很强。我们应该追求的是良好的设计，而不仅仅是可运行的程序, 聪明的程序员应该设计出易读性的代码。我就以这个程序为案例，介绍一下我认为合理的设计方法，牵引大家的视角从学习”语言”转移到学习”设计”上来。     
C#实现俄罗斯方块
热门推荐
天空
02-23 2万+
C#实现俄罗斯方块
C#实现对象映射
dogzhang
10-31 1万+
有时候会遇到这样的问题，两个对象具有很多相同的属性，已知一个对象，要给另外一个对象赋值，这时候需要每个属性逐一赋值，会比较麻烦。 如果不考虑性能问题的话，可以使用对象映射的方式来赋值，实际上是利用了反射的机制，达到动态生成对象和动态类型转换的目的。
C#编程实现俄罗斯方块详细教程
"C# 实现俄罗斯方块游戏...C#实现俄罗斯方块游戏是一个涉及图形用户界面编程、事件处理、二维数组操作以及简单的游戏逻辑的项目。通过这个项目，开发者可以提升对C#语言的理解，以及对游戏开发的基本流程和技巧的掌握。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值