C#编扫雷源码 08-5-02

最新推荐文章于 2022-05-03 21:01:54 发布
最新推荐文章于 2022-05-03 21:01:54 发布
阅读量5.2k 收藏 13
点赞数 1
分类专栏： 游戏开发 文章标签： c# 游戏 components 编程 windows dos

 

C# 编扫雷源码  08-5-02
C#编扫雷源码 一2008年03月23日 星期日 21:53
 
源代码：
[Form1.CS]
using  System;
 using  System.Drawing;
 using  System.Collections;
 using  System.ComponentModel;
 using  System.Windows.Forms;
 using  System.Data;

 namespace  MineClearance
 {
     /// <summary>
     /// Summary description for Form1.
     /// </summary>
     public class Form1 : System.Windows.Forms.Form
     {
         private System.Windows.Forms.MainMenu mainMenu1;
         private System.Windows.Forms.MenuItem menuItem1;
         private System.Windows.Forms.MenuItem menuItem2;
         private System.Windows.Forms.MenuItem menuItem3;
         private System.Windows.Forms.MenuItem menuItem4;
         private System.Windows.Forms.MenuItem menuItem5;
         private System.Windows.Forms.MenuItem menuItem6;
         private System.Windows.Forms.MenuItem menuItem7;
         private System.Windows.Forms.MenuItem menuItem9;
         private System.Windows.Forms.MenuItem menuItem12;
         private System.Windows.Forms.MenuItem menuItem13;
         private System.Windows.Forms.MenuItem menuItem14;
         private System.ComponentModel.IContainer components;

         private FaceControl faceControl1;
         private MineCountControl mineCountControl1;
         private TimerControl timerControl1;

         private int [ , ] Mine;//==-2时，表示这个地雷已经爆炸；==-1时，代表这个位置是地雷；否则代表周围的地雷的数量
         private int [ , ] Turn;//==-1 表示这个位置已经翻开；==0 表示这个位置没有翻开；==1 表示这个位置插上红旗；
         private int BoardWidth;//宽度
         private int BoardHeight;//高度
         private uint MineCount;
         private Point MP = new Point(0, 0);//用来记录鼠标点击的方格
         private bool GameStartMark;//游戏开始标志
         private uint Count
         {
             get
             {
                 return MineCount;
             }
             set
             {
                 MineCount = value;
                 mineCountControl1.mineCount = (int)value;
             }
         }

         public Form1()
         {
             //
             // Required for Windows Form Designer support
             //
             InitializeComponent();

             //
             // TODO: Add any constructor code after InitializeComponent call
             //
             mineCountControl1 = new MineCountControl();
             faceControl1 = new FaceControl();
             faceControl1.Click += new EventHandler(ClickFace);
             timerControl1 = new TimerControl();
             timerControl1.Rouse += new EventHandler(RouseTime);
             timerControl1.rouseTime = 999;
             Reset(9, 9, 10);
             this.CenterToScreen();

             this.Controls.Add(faceControl1);
             this.Controls.Add(mineCountControl1);
             this.Controls.Add(timerControl1);
         }

         /// <summary>
         /// Clean up any resources being used.
         /// </summary>
         protected override void Dispose( bool disposing )
         {
             if( disposing )
             {
                 if (components != null) 
                 {
                     components.Dispose();
                 }
             }
             base.Dispose( disposing );
         }

         Windows Form Designer generated code
/// <summary>
         /// The main entry point for the application.
         /// </summary>
         [STAThread]
         static void Main() 
         {
             Application.Run(new Form1());
         }

         //鼠标坐标转换成雷区方格的坐标
         private Point MToA(int x, int y)
         {
             x -= 13; y -= 53;
             if(x < 0 || x > BoardWidth * 20 || y < 0 || y > BoardWidth * 20 )
             {
                 throw new Exception();
             }
             x = x / 20;
             y = y / 20;
             return new Point(x , y);
         }

         //鼠标坐标转换成雷区绝对坐标，进行坐标越界处理
         private Point MToAT(int x, int y)
         {
             x = (x - 13) / 20;
             y = (y - 53) / 20;
             if(x < 0) x = 0;
             if(x > BoardWidth - 1) x = BoardWidth - 1;
             if(y < 0) y = 0;
             if(y > BoardHeight -1) y = BoardHeight -1;
             return new Point(x , y);
         }

         //判断一点是否在一区域内
         private bool InBox(System.Drawing.Rectangle rec1, System.Drawing.Point p1)
         {
             if( (rec1.Left <= p1.X && rec1.Top <= p1.Y) && (p1.X <= rec1.Right && p1.Y <= rec1.Bottom) ) return true;
             else return false;
         }
        
         //判断两区域是否交叉（有覆盖之处）
         private bool CrossBox(System.Drawing.Rectangle rec1, System.Drawing.Rectangle rec2)
         {
             //如果rec2有任何一个角在rec1中则视为交叉
             if( InBox(rec1, new Point(rec2.Left, rec2.Top)) == true) return true;
             if( InBox(rec1, new Point(rec2.Right, rec2.Top)) == true) return true;
             if( InBox(rec1, new Point(rec2.Left, rec2.Bottom)) == true) return true;
             if( InBox(rec1, new Point(rec2.Right, rec2.Bottom)) == true) return true;

             //如果rec1有任何一个角在rec2中则视为交叉
             if( InBox(rec2, new Point(rec1.Left, rec1.Top)) == true) return true;
             if( InBox(rec2, new Point(rec1.Right, rec1.Top)) == true) return true;
             if( InBox(rec2, new Point(rec1.Left, rec1.Bottom)) == true) return true;
             if( InBox(rec2, new Point(rec1.Right, rec1.Bottom)) == true) return true;

             if( (rec1.Left <= rec2.Left && rec2.Right <= rec1.Right) && (rec2.Top <= rec1.Top && rec1.Bottom <= rec2.Bottom) ) return true;
             if( (rec2.Left <= rec1.Left && rec1.Right <= rec2.Right) && (rec1.Top <= rec2.Top && rec2.Bottom <= rec1.Bottom) ) return true;

             return false;
         }

         //画立体方框
         private void ColorBox(int x1, int y1, int x2, int y2, int PenWidth, bool Down, bool Fill, Color FillColor)
         {
             System.Drawing.Graphics g = this.CreateGraphics();
             System.Drawing.Pen p = new Pen(Color.White, 1);//确定画笔的颜色和粗细
             for(; PenWidth > 0; PenWidth --)
             {
                 p.Color = (Down == false)? Color.White: Color.Gray;
                 g.DrawLine( p, x1, y1, x2, y1);
                 g.DrawLine( p, x1, y1, x1, y2);
                 p.Color = (Down == false)? Color.Gray: Color.White;
                 g.DrawLine( p , x2, y2, x2, y1);
                 g.DrawLine( p , x2, y2, x1, y2);
                 x1 ++; y1 ++;
                 x2 --; y2 --;
             }

             if( Fill == true )     g.FillRectangle(new SolidBrush(FillColor), x1, y1, x2 - x1 + 1, y2 - y1 + 1);
         }
 
        //自动清除无雷区
         private void ClearBoardMine(int nx, int ny)
         {
             if(InBox(new Rectangle(0,0,BoardWidth-1,BoardHeight-1), new Point(nx, ny)) == false) return;
             if( Mine[ny, nx] == -1 || Turn[ny, nx] == -1) return;
             Turn[ny, nx] = -1;
             ReDraw(new Point(nx, ny), new Point(nx, ny) );
             if( Mine[ny, nx] == 0)
             {
                 for(int i=ny-1; i<= ny+1; i++)
                 {
                     for(int j=nx-1; j<=nx+1; j++)
                     {
                         ClearBoardMine(j, i);
                     }
                 }
             }
         }

         //单击笑脸处理
         public void ClickFace(object sender, System.EventArgs e)
         {
             ReStart();
         }

         //超时处理
         public void RouseTime(object sender, System.EventArgs e)
         {
             timerControl1.Stop();
             System.Windows.Forms.MessageBox.Show("时间到了，这次你输了！ 没关系，别恢心，请继续努力！","游戏结束");
             ReStart();
         }

         protected override void OnPaint(PaintEventArgs e)
         {
             System.Drawing.Graphics g = e.Graphics;

             ColorBox(0, 0,this.ClientSize.Width, this.ClientSize.Height, 3, false, false, Color.Gainsboro);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), 3, 3, this.ClientSize.Width - 5, 7);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), 3, 3, 7, this.ClientSize.Height - 5);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), this.ClientSize.Width - 9 , 3, 7, this.ClientSize.Height - 5);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), 3, 41, this.ClientSize.Width - 5, 9);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), 3, this.ClientSize.Height - 9, this.ClientSize.Width - 5, 7);
             ColorBox(10, 10, this.ClientSize.Width-10, 40, 2, true, false, Color.Gainsboro);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), mineCountControl1.Right, 12, faceControl1.Left - mineCountControl1.Right, 27);
             g.FillRectangle(new SolidBrush(Color.Gainsboro), faceControl1.Right, 12, timerControl1.Left - faceControl1.Right , 27);

             ColorBox(10, 50, this.ClientSize.Width-10, this.ClientSize.Height-10, 3, true, false, Color.Gainsboro);

             ReDraw( this.MToAT(e.ClipRectangle.Left, e.ClipRectangle.Top), this.MToAT(e.ClipRectangle.Right, e.ClipRectangle.Bottom) );
         } 


         protected override void OnMouseDown(MouseEventArgs e)
         {
             Point p;
             try
             {
                 p = MToA(e.X, e.Y);
             }
             catch
             {
                 return;
             }
             if(Turn[p.Y, p.X] == -1 || GameStartMark == false)//方格被翻开或游戏结束
             {
                 return;
             }
             timerControl1.Start();
             switch(e.Button)
             {
                 case MouseButtons.Left:
                     faceControl1.faceState = FaceControl.FaceState.Startle;
                     if(Turn[p.Y, p.X] != 1 )//未插红旗
                     {
                         DrawMine( p.X, p.Y, -4);
                         //记录鼠标单击时按下的方格
                         MP.X = p.X;     MP.Y = p.Y;
                     }
                     break;
                 case MouseButtons.Right:
                     if(Turn[p.Y, p.X] == 0)//未插红旗则插入红旗
                     {
                         Turn[p.Y, p.X] = 1;
                         mineCountControl1.mineCount --;
                     }
                     else
                     {
                         Turn[p.Y, p.X] = 0;
                         mineCountControl1.mineCount ++;
                     }
                     ReDraw(p, p);
                     break;
             }
         }

         protected override void OnMouseUp(MouseEventArgs e)
         {
             Point p;
             try
             {
                 p = MToA(e.X, e.Y);
             }
             catch
             {
                 if(InBox(new System.Drawing.Rectangle(0, 0, BoardWidth - 1, BoardHeight - 1), MP) == true) ReDraw(MP, MP);
                 faceControl1.faceState = FaceControl.FaceState.Up;
                 return;
             }
             if(GameStartMark == false)//如果游戏结束
             {
                 return;
             }
             switch(e.Button)
             {
                 case MouseButtons.Left:
                     if(MP.X == p.X && MP.Y == p.Y && Turn[p.Y, p.X] != 1)//未插红旗
                     {
                         if(Turn[p.Y, p.X] != -1 )//未被翻开
                         {
                             if(Mine[p.Y, p.X] == 0)//如果这个位置周围没有地雷
                             {
                                 ClearBoardMine(p.X, p.Y);//自动清除无雷区
                             }
                             else
                             {
                                 Turn[p.Y, p.X] = -1;
                                 if(Mine[p.Y, p.X] == -1)//碰到地雷
                                 {
                                     timerControl1.Stop();
                                     Mine[p.Y, p.X] = -2;
                                     //游戏结束
                                     for(int i=0; i< BoardHeight; i++)
                                     {
                                         for(int j=0; j< BoardWidth; j++)
                                         {
                                             Turn[i, j] = -1;
                                         }
                                     }
                                     ReDraw(new Point(0, 0), new Point(BoardWidth-1, BoardHeight-1) );
                                     faceControl1.faceState = FaceControl.FaceState.Die;
                                     GameStartMark = false;
                                     return;
                                 }
                                 ReDraw( p, p );
                             }
                             faceControl1.faceState = FaceControl.FaceState.Up;
                             //统计游戏结果
                             int tn=0;
                             for(int i=0; i< BoardHeight; i++)
                             {
                                 for(int j=0;j< BoardWidth; j++)
                                 {
                                     if(Turn[i,j] == -1) tn++;
                                 }
                             }
                             if(tn == (BoardWidth * BoardHeight - MineCount) )//胜利
                             {
                                 timerControl1.Stop();
                                 System.Windows.Forms.MessageBox.Show("恭喜您凯旋归来！","游戏结束");
                                 ReStart();
                             }
                         }
                     }
                     else
                     {
                         if(InBox(new System.Drawing.Rectangle(0, 0, BoardWidth - 1, BoardHeight - 1), MP) == true) ReDraw(MP, MP);
                         faceControl1.faceState = FaceControl.FaceState.Up;
                     }
                     break;
             }
         }
   //重画
    private void ReDraw(Point p1, Point p2)
    {
        if (InBox(new Rectangle(0, 0, BoardWidth - 1, BoardHeight - 1), p1) == false || InBox(new Rectangle(0, 0, BoardWidth - 1, BoardHeight - 1), p2) == false) return;
        System.Drawing.Graphics g = this.CreateGraphics();
        for (int i = p1.Y; i <= p2.Y; i++)
        {
            for (int j = p1.X; j <= p2.X; j++)
            {
                switch (Turn[i, j])
                {
                    case 0://未动过 
                        DrawMine(j, i, -3);
                        break;
                    case 1://插入红旗
                        DrawMine(j, i, -5);
                        break;
                    default:
                        DrawMine(j, i, Mine[i, j]);
                        break;
                }
            }
        }
    }
    //重画
    private void ReDraw()
    {
        System.Drawing.Graphics g = this.CreateGraphics();
        System.Drawing.Rectangle rec = new Rectangle(0, 0, this.ClientRectangle.Right, this.ClientRectangle.Bottom);
        OnPaint(new PaintEventArgs(g, rec));
    }
    //重新开始
    private void ReStart()
    {
        Reset(BoardWidth, BoardHeight, MineCount);
    }
    //以指定的行、列和地雷数量初始化,重新开始
    private void Reset(int NWidth, int NHeight, uint NCount)
    {
        System.Random ran = new Random(System.DateTime.Now.Second + (int)System.DateTime.Now.Ticks);
        BoardWidth = NWidth;
        BoardHeight = NHeight;
        Count = NCount;
        Mine = new int[NHeight, NWidth];
        Turn = new int[NHeight, NWidth];
        //初始化地雷
        for (int i = 0; i < NHeight; i++)
        {
            for (int j = 0; j < NWidth; j++)
            {
                Mine[i, j] = 0; Turn[i, j] = 0;
            }
        }
        //生成 N 颗地雷 
        for (int i = 0; i < NCount; i++)
        {
            int nx, ny; do
            {
                nx = ran.Next(0, NWidth); ny = ran.Next(0, NHeight);
            }
            while (Mine[ny, nx] == -1); Mine[ny, nx] = -1;
            //描述雷区 
            for (int j = nx - 1; j <= nx + 1; j++)
            {
                for (int k = ny - 1; k <= ny + 1; k++)
                {
                    if ((j >= 0 && j < NWidth) && (k >= 0 && k < NHeight))
                    {
                        if (Mine[k, j] != -1) Mine[k, j]++;
                    }
                }
            }
        }
        this.ClientSize = new System.Drawing.Size(26 + BoardWidth * 20, 66 + BoardHeight * 20);
        //设置窗体大小
        GameStartMark = true; mineCountControl1.Location = new Point(20, 13);
        faceControl1.Location = new Point(this.ClientSize.Width / 2 - 10, 15);
        timerControl1.Location = new Point(this.ClientSize.Width - 70, 13);
        timerControl1.Clear();
        ReDraw();
        faceControl1.faceState = FaceControl.FaceState.Up;
    }
    //在指定位置画物件 
    private void DrawMine(int x, int y, int Value)
    {
        System.Drawing.Graphics g = this.CreateGraphics();
        System.Drawing.Pen p = new Pen(Color.Black, 1);
        //确定画笔的颜色和粗细 
        System.Drawing.Color textColor = new Color();
        x = 13 + x * 20; y = 53 + y * 20;
        switch (Value)
        {
            case -5://画红旗   
                ColorBox(x, y, x + 19, y + 19, 2, false, true, Color.Gainsboro);
                g.DrawLine(p, x + 8, y + 14, x + 12, y + 14);
                g.FillPolygon(new SolidBrush(Color.Red), new Point[] { new Point(x + 12, y + 11), new Point(x + 12, y + 2), new Point(x + 5, y + 7) });
                p.Width = 2; g.DrawLine(p, x + 5, y + 16, x + 15, y + 16);
                g.DrawLine(p, x + 11, y + 11, x + 11, y + 14);
                return;
            case -4://画按下的区域 
                ColorBox(x, y, x + 19, y + 19, 2, true, true, Color.Gainsboro);
                return;
            case -3://画未按下的区域   
                ColorBox(x, y, x + 19, y + 19, 2, false, true, Color.Gainsboro);
                return;
            case -2://画爆炸的地雷 
            case -1://画未爆炸的地雷 
                g.DrawRectangle(new Pen(System.Drawing.Color.Gray, 2), x + 1, y + 1, 19, 19);
                g.FillRectangle(new SolidBrush((Value == -2) ? Color.Red : Color.Gainsboro), x + 2, y + 2, 17, 17);
                g.FillEllipse(new SolidBrush(Color.Black), x + 4, y + 4, 12, 12);
                g.DrawLine(p, x + 4, y + 4, x + 16, y + 16); g.DrawLine(p, x + 10, y + 3, x + 10, y + 17);
                g.DrawLine(p, x + 15, y + 4, x + 4, y + 15);
                g.DrawLine(p, x + 3, y + 10, x + 18, y + 10);
                g.FillEllipse(new SolidBrush(Color.White), x + 7, y + 7, 3, 3);
                return;
            default:
                //确定字体颜色 
                switch (Value)
                {
                    case 0: textColor = Color.Gainsboro; break;
                    case 1: textColor = Color.Blue; break;
                    case 2: textColor = Color.Green; break;
                    case 3: textColor = Color.Red; break;
                    case 4: textColor = Color.DarkBlue; break;
                    case 5: textColor = Color.DarkGreen; break;
                    case 6: textColor = Color.DarkRed; break;
                    case 7: textColor = Color.Fuchsia; break;
                    case 8: textColor = Color.Black; break;
                }
                //显示周围的雷数 
                g.DrawRectangle(new Pen(System.Drawing.Color.Gray, 2), x + 1, y + 1, 19, 19);
                g.FillRectangle(new SolidBrush(Color.Gainsboro), x + 2, y + 2, 17, 17);
                g.DrawString(Value.ToString(), this.Font, new System.Drawing.SolidBrush(textColor), x + 2, y - 2);
                return;
        }
    }
    private void menuItem3_Click(object sender, System.EventArgs e)
    {
        ReStart();
    }
    private void menuItem4_Click(object sender, System.EventArgs e)
    {
        Reset(9, 9, 10);
    }
    private void menuItem6_Click(object sender, System.EventArgs e)
    {
        Reset(16, 16, 40);
    }
    private void menuItem7_Click(object sender, System.EventArgs e)
    {
        Reset(30, 16, 99);
    }
    private void menuItem13_Click(object sender, System.EventArgs e)
    {
        new Help().ShowDialog();
    }
    private void menuItem14_Click(object sender, System.EventArgs e)
    {
        new About().ShowDialog();
    }
    private void menuItem12_Click(object sender, System.EventArgs e)
    {
        Application.Exit();
    }
}

       扫雷这个游戏我以前用Turb C做过，Dos界面，图像效果很差。而且我整整做了三个星期。这回用VS.Net重做感觉不同了，窗口编程容易了许多，做出来的效果也好了很多，几乎和Windows的扫雷差不了多少。直到现在我才明白为什么C#被称为用于编写"下一代窗口服务"，由于平易近人的图形界面极大的减轻了源代码编程的负担，VS.Net可以在较短周期内开发应用程序，所开发的程序又具有良好的可移植性。我想C#至关重要的各种要素就是下面这些吧：简单　

C#中，没有C++中流行的指针。在C++中，有::、.、和->操作符，它们用于名字空间、成员和引用。对于新手来说，操作符至今仍是学习的一道难关。C#弃用其它操作符，仅使用单个操作符 "."。现在一个程序员所需要理解的就是嵌套名字的注解了。C#使用统一的类型系统，屏弃了C++多变的类型系统。这种系统充许您把各种类型作为一个对象查看，它是一个原始类型还是一个full-blown 类。和其它编程语言相比，由于加框(boxing)和消框(unboxing)的机制，把简单类型当作对象处理并不能获得性能的改善。
xiamin
关注
专栏目录
扫雷游戏C#源码
01-25
用C#开发的一款扫雷游戏，可以直接运行，供学习使用！
C#扫雷源代码
11-08
内容包含C#编写的扫雷源代码！适合初学C#的编程人员阅读！
c#扫雷源码
05-14
c#扫雷源码，入门者参考
C# 扫雷源码（完全资源版）
10-25
与Windows的扫雷游戏几乎一样的C# 扫雷源码！！！！
C#编的扫雷游戏源码
09-07
自己用C#编的一个扫雷游戏，功能跟微软的基本相同，调用递归来完成自动排雷，第一次做游戏，大家可以交流交流
C# 扫雷游戏源码Bomb-非常适合初学者学习
08-06
C# 扫雷游戏源码Bomb-非常适合初学者学习，C# 扫雷游戏源码Bomb-非常适合初学者学习，C# 扫雷游戏源码Bomb-非常适合初学者学习，重要的事情说三遍
基于C#实现的扫雷游戏源码
最新发布
03-20
在本项目中，"基于C#实现的扫雷游戏源码"是一个用于教学或个人学习目的的编程实例，它展示了如何使用C#编程语言来创建一个经典的扫雷游戏。扫雷游戏是一个广为人知的逻辑游戏，玩家需要通过点击游戏面板上的方块来找...
C# 制作的扫雷--源码
10-23
C# 制作的扫雷--包含源码，内有详细注释，保证能无误运行！ 应好友请求今天将资源分从 10分 减为 3分 。 2010.10.26. 今日起资源分再降 1 分，以后就要 2 分算了，感谢大家的支持！！ 2010.10.29
C#扫雷游戏源码.rar
04-05
C#扫雷游戏源码是一款基于C#编程语言开发的经典扫雷游戏，它展示了C#在创建图形用户界面（GUI）和实现逻辑算法方面的应用。通过分析这款源码，我们可以深入学习C#的基础知识，以及如何利用C#进行游戏开发。 首先，...
c#编写扫雷游戏包含源代码
05-12
地雷游戏的源码，程序很简单，注释有点少，都是很初级的，多看两次就懂了，高手见谅。
c#版扫雷源代码及注释
12-25
这是我们的课程作业，用了不少的时间进行了设计。 使用了几种比较常见的设计模式比如单例模式，工厂模式，只是为了练习一下设计模式的用法。 有十分详细的注释以及修改原因、编写时间、函数功能等。 愿与大家一块分享，愿高手批评指教。
c#版扫雷游戏，和windows里的一样（源代码）
07-12
c#写的和windows里自带的一样的扫雷游戏
C# 扫雷项目代码
04-16
Unity，C#简易版的扫雷，实现扫雷的基本操作，插旗算法，以及排零算法
C# 扫雷游戏代码
10-22
C# 扫雷游戏代码
C# 扫雷源码及注释
08-09
C# 扫雷源码及注释，适合菜鸟学习
C#做的扫雷游戏源码
m0_37721250的博客
02-25 1030
2020年初新冠病毒闹的在家出不去，也没什么事干，看到孩子在玩扫雷游戏，自己跟着玩了几把。 网上下的扫雷都不能改变窗口大小，在高分辩率显示屏上雷块太小，鼠标总是点不上。 自己好多年没有做过开发了，一时冲动觉得反正闲着，就试着做了一个可以改变窗口大小扫雷，现在将源码分享给大家。 开发环境Visual studio 2012，开发语言C#，基础需求.NET Framework2.0 ...
C#扫雷源码，让你眼前一亮
qq_65496815的博客
05-03 897
现代设计 16*16方块，40雷 简约动画 Random random = new Random(); public void ScaleEasingAnimationShow(UIElement element, double Sizefrom, double Sizeto, int power, TimeSpan time) { if ((element as Button).Tag == null) .
C#如何开发扫雷游戏
weixin_34032621的博客
06-08 411
简单的总结一下，如何利用C#进行WinForm扫雷小游戏的开发： 扫雷游戏的主要设计的类有三个：Main、Pane、MineField 1）Main是主控窗体，负责项目的启动和关闭；并协调内部各个组建模块的协调工作。 2）Pane是一个方格的封装，是雷区的重要组建；它表示一个方格的当前状态，以及是否布雷等信息。 3）MineField是雷区的封装，是游戏的...
C# windows简单扫雷源代码
天地不仁，以万物为刍狗
10-14 1629
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq
C#与openssl DES-CBC加密一致性实现
"本文档主要讨论了在C#中模拟openssl的DES-CBC加密过程中遇到的问题以及解决方案。在尝试使用dllimport直接调用openssl库时，可能会遇到内存指针错误，尤其是在大量循环加密时。作者提供了一种避免该问题的方法，并...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值