精华内容
下载资源
问答
  • 一个小游戏,类似于接苹果的游戏,可直接打开,不过本人做的不是很好,希望对下载的朋友有所帮助
  • c#窗体游戏设计设计王者荣耀,如何写鲁班七号放技能给后翼,后裔血量减少最终死了的程序![图片说明](http://forum.csdn.net/PointForum/ui/scripts/csdn/Plugin/001/face/6.gif)
  • C#窗体打字游戏

    2015-05-09 23:15:27
    关于简单的C#游戏制作 ,主要熟悉代码操作,理解C#timer等控件使用
  • C#窗体实现贪吃蛇,程序简单易懂,开发平台vs2010
  • C# 窗体 仿做俄罗斯方块 游戏 源码例子
  • 一款简单的c#窗体程序,用户可以输入号码进行猜奖,如同3D彩票
  • 一个,窗体C#编写小游戏,主要是思路,希望有意者下载.
  • C#窗体连连看小游戏(超详细)

    千次阅读 多人点赞 2020-12-17 17:52:31
    文章目录成品链接项目展示全部代码窗体控件命名连连看功能类窗体功能实现各部分功能解释一、项目分析二、项目设计 成品链接 项目展示 全部代码 窗体控件命名 namespace Linkup { partial class MainWindow { //...

    成品链接

    https://download.csdn.net/download/weixin_45525272/13713452

    项目展示

    在这里插入图片描述
    在这里插入图片描述

    各部分功能解释

    一、项目分析

    系统设计思路

    (1)设计连连看功能类:LinkClass,Line
    (2)设计两个事件:成功事件和失败事件
    (3)成功事件:1.垂直事件2.水平事件3.一个拐点事件4.两个拐点事件
    (4)失败事件:

    1. 一个按钮点击两次
    2. 点击的两个按钮所带图片不一样
    3. 点击两个具有相同图案的按钮但没有通路

    (5)可以选择三种行和列:88,1010,12*12
    (6)可以选择两种模式:数字,图片
    (7)设计随机数并且随机数要配对
    (8)赋予按钮应有的相关属性
    (9)计时器设计,暂停按钮时计时器停止计时,开始按钮显示继续游戏
    (10)每消除一对图片,计分加100
    (11)重新排列功能,每重新排列一次总得分减400

    二、项目设计

    一、难度和模式
    用两个comboBox分别设计行和列,图片或者数字模式

    
    if (comboBox1.Text == ""|| comboBox2.Text=="")
    {
       MessageBox.Show("请选择难度或者模式", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    else
    {
       // 选择的关卡难度文本
       string Diffcult = comboBox1.Text;
       //根据对应难度初始化数组并给n赋值
       switch (Diffcult)
       {
           case "8*8":
               hang = 8;
               break;
           case "10*10":
               hang = 10;
               break;
           case "12*12":
               hang = 12;
               break; 
       }
    //判断用户选的是图片还是数字
             string mul = comboBox2.Text;
             if (mul == "数字")
             {
                 Button btnLinker = new Button() // 设置每个小按钮的相关属性
                 {
                     Text = rnd.ToString(),//按钮上显示的是随机数
                     Tag = img,//标签
                     Name = string.Format("{0},{1}", row, col),//每个按钮命名
                     Dock = DockStyle.Fill,//调整控件层次,填充
                     Margin = new Padding(1),//调整外边距
                 };
                 btnLinker.Click += BtnLinker_Click; // 让每个按钮都拥有点击事件
                 this.TableLp.Controls.Add(btnLinker, col, row);//将按钮加进去并赋给位置
             }
             else//即用户选择了图片
             {
                 Button btnLinker = new Button() // 设置每个小按钮的相关属性
                 {
                     BackgroundImage = GetImageByName(img),//给按钮填充背景图片
                     BackgroundImageLayout = ImageLayout.Stretch,//背景图片拉申
                     Tag = img,
                     Name = string.Format("{0},{1}", row, col),
                     Dock = DockStyle.Fill,
                     Margin = new Padding(1),
                 };
                 btnLinker.Click += BtnLinker_Click; // 让每个按钮都拥有点击事件
                 this.TableLp.Controls.Add(btnLinker, col, row);
             }
         }
       }
       this.LinkObj.LinkBoard = linkBoard;//初始化棋盘
       this.TableLp.Enabled = false;
    
    

    2、进度条分数模块
    用计时器线程来计时,进行进度条与时间标签的实时更新

    
            // 计时器线程
            Thread timeDelay;       // 线程变量
            int timetemp = 0;       // 计时器中间变量
     // 定时器事件:时间剩余
            void timeDelay_Tick()
            {
                //ma.WaitOne(); // 根据是否收到信号判断是否阻塞当前线程
                while (this.curDelay > 0 )   // 当前时间大于零
                {
                    if (!isClosing)
                    {
                        this.curDelay--;
                        this.pbTimeDelay.Value = this.curDelay;
                        this.lblTimeDelay.Text = this.curDelay.ToString();
                        
                    }
                    Thread.Sleep(1000);
                }
                if (!isClosing)
                {
                  
                    this.btnStart.Enabled = true;
                    this.TableLp.Enabled = false;
                  
                }
            }
    

    3、开始游戏(游戏初始化)
    清除残余,并且设置新的表格

    this.TableLp.ColumnStyles.Clear();
                    this.TableLp.RowStyles.Clear();
                    this.TableLp.Controls.Clear();
    this.TableLp.ColumnCount = hang + 2;
                    this.TableLp.RowCount = hang + 2;
    
    设置按钮及边框所占的比列
    for (int i = 0; i < hang + 2; i++)
                    {
                        //设置等宽等高  边缘2,里面内容10
                        if (i == 0 || i == hang + 1)
                        {
                            this.TableLp.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 2));//占总画面的2%
                            this.TableLp.RowStyles.Add(new RowStyle(SizeType.Percent, 2));
                        }
                        else
                        {
                            this.TableLp.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 10));//占总画面的10%
                            this.TableLp.RowStyles.Add(new RowStyle(SizeType.Percent, 10));
                        }
                    }
    
    为每个按钮赋给图片或者相应的数字
     string img = string.Format("_1_{0}", rnd.ToString("00"));//给图片命名
                            linkBoard[row, col] = rnd;//赋给每个位置随机数字
                            //判断用户选的是图片还是数字
                            string mul = comboBox2.Text;
                            if (mul == "数字")
                            {
                                Button btnLinker = new Button() // 设置每个小按钮的相关属性
                                {
                                    Text = rnd.ToString(),//按钮上显示的是随机数
                                    Tag = img,//标签
                                    Name = string.Format("{0},{1}", row, col),//每个按钮命名
                                    Dock = DockStyle.Fill,//调整控件层次,填充
                                    Margin = new Padding(1),//调整外边距
                                };
                                btnLinker.Click += BtnLinker_Click; // 让每个按钮都拥有点击事件
                                this.TableLp.Controls.Add(btnLinker, col, row);//将按钮加进去并赋给位置
                            }
                            else//即用户选择了图片
                            {
                                Button btnLinker = new Button() // 设置每个小按钮的相关属性
                                {
                                    BackgroundImage = GetImageByName(img),//给按钮填充背景图片
                                    BackgroundImageLayout = ImageLayout.Stretch,//背景图片拉申
                                    Tag = img,
                                    Name = string.Format("{0},{1}", row, col),
                                    Dock = DockStyle.Fill,
                                    Margin = new Padding(1),
                                };
                                btnLinker.Click += BtnLinker_Click; // 让每个按钮都拥有点击事件
                                this.TableLp.Controls.Add(btnLinker, col, row);
                            }
                        }
      }
    

    4、暂停游戏
    通过将当前时间的变量赋值为0来结束当前计时器线程,并且当点击继续游戏的时候,通过开启新线程来重新运行计数功能

    暂停

            private void btnPause_Click(object sender, EventArgs e)
            {
                this.TableLp.Enabled = false;
      
                btnStart.Enabled = true;
                btnStart.Text = "继续游戏";
                //ma.Reset();//信号关闭阻塞当前线程
    
                timetemp = this.curDelay;
                this.curDelay = 0;
                lblTimeDelay.Text = timetemp.ToString();
           }
    

    继续

     else if (btnStart.Text == "继续游戏")
                {
                    //ma.Set();//信号打开,不阻塞当前线程
                    btnStart.Text = "开始游戏";
                    btnStart.Enabled = false;
                    this.TableLp.Enabled = true;
                    this.curDelay= timetemp;// 将中间变量赋值给新的当前时间
                    lblTimeDelay.Text = this.curDelay.ToString();
                    timeDelay = new Thread(new ThreadStart(this.timeDelay_Tick));//新的计时器
                    timeDelay.Start();
                }
    

    5、重新排列
    设置随机二维数组,将原来的数字所在的行和列用随机的二维数组替代

    int rnd, rnd2;
                    // 打乱二维数组顺序
                    for (int row = 1; row < hang + 1; row++)
                    {
                        for (int col = 1; col < hang + 1; col++)
                        {
                            // 产生随机数
                            rnd = r.Next(1, 1000) % hang + 1;
                            rnd2 = r.Next(1, 1000) % hang + 1;
    
                            int temp = linkBoard[rnd, rnd2];
                            linkBoard[rnd, rnd2] = linkBoard[row, col];
                            linkBoard[row, col] = temp;
    
                        }
                    }
    

    6、判断连接的核心算法
    (1)垂直事件
    获取按钮1和按钮2的y值,并利用循环来判断按钮1和按钮2之间是否为通路

     private bool vertical(Point a, Point b)
            {
                int col_start = a.Y < b.Y ? a.Y : b.Y;    //获取a,b中较小的y值
                int col_end = a.Y < b.Y ? b.Y : a.Y;      //获取a,b中较大的y值
    
                //遍历a,b之间是否通路,如果一个不是就返回false;
                for (int i = col_start + 1; i < col_end; i++)
                {
                    if (this.LinkBoard[a.X, i] != 0)//0是空的状态(即没有按钮)
                    {
                        return false;
                    }
                }
                return true;
            }
    

    (2)水平事件
    获取按钮1和按钮2的x值,并利用循环来判断按钮1和按钮2之间是否为通路

    private bool horizon(Point a, Point b)
            {
                int row_start = a.X < b.X ? a.X : b.X;//获取a,b中较小的x值
                int row_end = a.X < b.X ? b.X : a.X;//获取a,b中较大的x值
                for (int i = row_start + 1; i < row_end; i++)
                {
                    if (this.LinkBoard[i, a.Y] != 0)//0是空的状态(即没有按钮)
                    {
                        return false;//return是函数结束
                    }
                }
                return true;
            }
    

    (3)一个拐点事件
    首先判断拐点位置是否有按钮,若没有,将剩下部分看做由一个垂直事件和一个水平事件组成

    private bool oneCorner(Point a, Point b)
            {
                // 拐角点的x,y分别等于两点各个x,y
                Point c = new Point(b.X, a.Y);
                Point d = new Point(a.X, b.Y);
                // 判断C点是否有元素,有就继续执行下面判断条件,没有就看a与c,b与c之间是否能水平或者垂直连线                
                if (this.LinkBoard[c.X, c.Y] == 0)
                {
                    bool path1 = vertical(b, c) && horizon(a, c);
                    return path1;   //path1本身就是bool值
                }
    
                //判断D点是否有元素
                if (this.LinkBoard[d.X, d.Y] == 0)
                {
                    bool path2 = vertical(a, d) && horizon(b, d);
                    return path2;//path2本身就是bool值
                }
                
                // 能执行到这就说明前面判断不成功,不存在一个拐点的情况
                return false;
               
            }
    

    (4)两个拐点事件
    首先判断两个拐点是都有按钮,并且判断两个拐点间是否为通路,此过程用到新建的scan函数,剩下即有两个水平事件或者两个垂直事件构成

    private List<Line> scan(Point a, Point b)
            {
                List<Line> linkList = new List<Line>();// 新建一个直线对象List容器,用来存成立的拐点之间的直线
    
                //检测a点上方是否能够水平直连
                for (int i = a.Y; i >= 0; i--)
                {
                    if (this.LinkBoard[a.X, i] == 0 && this.LinkBoard[b.X, i] == 0 && horizon(new Point(a.X, i), new Point(b.X, i)))
                    {
                        linkList.Add(new Line(new Point(a.X, i), new Point(b.X, i), 0));
                    }
                }
    
                //检测a点下方是否能够水平直连
                for (int i = a.Y; i < Col; i++)
                {
                    if (this.LinkBoard[a.X, i] == 0 && this.LinkBoard[b.X, i] == 0 && horizon(new Point(a.X, i), new Point(b.X, i)))
                    {
                        linkList.Add(new Line(new Point(a.X, i), new Point(b.X, i), 0));
                    }
                }
    
                //检测a点左侧是否能够垂直直连
                for (int j = a.X; j >= 0; j--)
                {
                    if (this.LinkBoard[j, a.Y] == 0 && this.LinkBoard[j, b.Y] == 0 && vertical(new Point(j, a.Y), new Point(j, b.Y)))
                    {
                        linkList.Add(new Line(new Point(j, a.Y), new Point(j, b.Y), 1));
                    }
                }
    
                //检测a点右侧是否能够垂直直连
                for (int j = a.X; j < Row; j++)
                {
                    if (this.LinkBoard[j, a.Y] == 0 && this.LinkBoard[j, b.Y] == 0 && vertical(new Point(j, a.Y), new Point(j, b.Y)))
                    {
                        linkList.Add(new Line(new Point(j, a.Y), new Point(j, b.Y), 1));
    
                    }
                }
    
                return linkList;
            }
    }
     private bool twoCorner(Point a, Point b)
            {
                // list容器:相当于一个Line类型的数组,存扫到的连通路径
                List<Line> ll = scan(a, b);//此时的直线已经判断成功并且拐点位置没有数字
                if (ll.Count == 0)  // 没扫到返回false,List容器里面的计数方法
                {
                    return false;
                }
    
                for (int i = 0; i < ll.Count; i++)
                {
                    Line tempLine = ll[i];  // 临时连线变量用于判断拐点与a,b的通路是否成立
                    if (tempLine.direct == 1)   // 两个拐点之间是水平直连
                    {// 判断分别两个拐点与a,b能否相连
                        if (horizon(a, tempLine.a) && horizon(b, tempLine.b))//判断a与a"之间是否有通路;判断b与b"之间是否有通路
                        {
                            return true;
                        }
                    }
                    else if (tempLine.direct == 0)  // 两个拐点之间是垂直直连
                    {// 判断分别两个拐点与a,b能否相连
                        if (vertical(a, tempLine.a) && vertical(b, tempLine.b))//判断a与a"之间是否有通路;判断b与b"之间是否有通路
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
    
    

    7.重新排列
    将原本储存的二维数组重新打乱顺序,在按照打乱后的数组动态生成按钮

      // 打乱二维数组顺序
          for (int row = 1; row < hang + 1; row++)
          {
              for (int col = 1; col < hang + 1; col++)
              {
                  // 产生随机数
                  rnd = r.Next(1, 1000) % hang + 1;
                  rnd2 = r.Next(1, 1000) % hang + 1;
    
                  int temp = linkBoard[rnd, rnd2];
                  linkBoard[rnd, rnd2] = linkBoard[row, col];
                  linkBoard[row, col] = temp;
    
              }
          }
    
    

    8.连接成功判断
    用两个循环挨个遍历数组元素并计数,最后判断计数是否够元素的个数

            // 判断成功
            private void Judge()
            {
                int count=0;
                // 将内置元素进行随机数分配等操作
                for (int row = 1; row < hang + 1; row++)
                {
                    for (int col = 1; col < hang + 1; col++)
                    {
                        if (this.LinkObj.LinkBoard[row,col]==0)
                        {
                            count++;
                        }
                    }
                }
                if (count==hang*hang)
                {
                    MessageBox.Show("拼完了,你可真厉害!","提示",MessageBoxButtons.OK,MessageBoxIcon.Asterisk);
                    this.TableLp.Enabled = false;
                    btnStart.Enabled = true;
    
                    timetemp = this.curDelay;
                    this.curDelay = 0;
                    lblTimeDelay.Text = timetemp.ToString();
                }
            }
    
    

    全部代码

    窗体控件命名

    namespace Linkup
    {
        partial class MainWindow
        {
            /// <summary>
            /// 必需的设计器变量。
            /// </summary>
            private System.ComponentModel.IContainer components = null;
    
            /// <summary>
            /// 清理所有正在使用的资源。
            /// </summary>
            /// <param name="disposing">如果应释放托管资源,为 true;否则为 false。</param>
            protected override void Dispose(bool disposing)
            {
                if (disposing && (components != null))
                {
                    components.Dispose();
                }
                base.Dispose(disposing);
            }
    
            #region Windows 窗体设计器生成的代码
    
            /// <summary>
            /// 设计器支持所需的方法 - 不要修改
            /// 使用代码编辑器修改此方法的内容。
            /// </summary>
            private void InitializeComponent()
            {
                System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainWindow));
                this.TableLp = new System.Windows.Forms.TableLayoutPanel();
                this.btnStart = new System.Windows.Forms.Button();
                this.pbTimeDelay = new System.Windows.Forms.ProgressBar();
                this.lblTimeDelay = new System.Windows.Forms.Label();
                this.lableScore = new System.Windows.Forms.Label();
                this.btnStop = new System.Windows.Forms.Button();
                this.comboBox1 = new System.Windows.Forms.ComboBox();
                this.btnPause = new System.Windows.Forms.Button();
                this.btnReset = new System.Windows.Forms.Button();
                this.comboBox2 = new System.Windows.Forms.ComboBox();
                this.label1 = new System.Windows.Forms.Label();
                this.label2 = new System.Windows.Forms.Label();
                this.SuspendLayout();
                // 
                // TableLp
                // 
                this.TableLp.ColumnCount = 1;
                this.TableLp.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 50F));
                this.TableLp.Location = new System.Drawing.Point(61, 12);
                this.TableLp.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.TableLp.Name = "TableLp";
                this.TableLp.RowCount = 1;
                this.TableLp.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 50F));
                this.TableLp.Size = new System.Drawing.Size(534, 534);
                this.TableLp.TabIndex = 0;
                // 
                // btnStart
                // 
                this.btnStart.Location = new System.Drawing.Point(697, 44);
                this.btnStart.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.btnStart.Name = "btnStart";
                this.btnStart.Size = new System.Drawing.Size(243, 36);
                this.btnStart.TabIndex = 1;
                this.btnStart.Text = "开始游戏";
                this.btnStart.UseVisualStyleBackColor = true;
                this.btnStart.Click += new System.EventHandler(this.btnStart_Click);
                // 
                // pbTimeDelay
                // 
                this.pbTimeDelay.Location = new System.Drawing.Point(61, 573);
                this.pbTimeDelay.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.pbTimeDelay.Name = "pbTimeDelay";
                this.pbTimeDelay.Size = new System.Drawing.Size(451, 19);
                this.pbTimeDelay.Style = System.Windows.Forms.ProgressBarStyle.Continuous;
                this.pbTimeDelay.TabIndex = 2;
                // 
                // lblTimeDelay
                // 
                this.lblTimeDelay.AutoSize = true;
                this.lblTimeDelay.Location = new System.Drawing.Point(542, 573);
                this.lblTimeDelay.Name = "lblTimeDelay";
                this.lblTimeDelay.Size = new System.Drawing.Size(15, 15);
                this.lblTimeDelay.TabIndex = 3;
                this.lblTimeDelay.Text = "0";
                // 
                // lableScore
                // 
                this.lableScore.AutoSize = true;
                this.lableScore.Location = new System.Drawing.Point(724, 573);
                this.lableScore.Name = "lableScore";
                this.lableScore.Size = new System.Drawing.Size(60, 15);
                this.lableScore.TabIndex = 4;
                this.lableScore.Text = "分数:0";
                // 
                // btnStop
                // 
                this.btnStop.Location = new System.Drawing.Point(697, 160);
                this.btnStop.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.btnStop.Name = "btnStop";
                this.btnStop.Size = new System.Drawing.Size(243, 36);
                this.btnStop.TabIndex = 1;
                this.btnStop.Text = "结束游戏";
                this.btnStop.UseVisualStyleBackColor = true;
                this.btnStop.Click += new System.EventHandler(this.btnStop_Click);
                // 
                // comboBox1
                // 
                this.comboBox1.FormattingEnabled = true;
                this.comboBox1.Location = new System.Drawing.Point(780, 318);
                this.comboBox1.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.comboBox1.Name = "comboBox1";
                this.comboBox1.Size = new System.Drawing.Size(160, 23);
                this.comboBox1.TabIndex = 5;
                // 
                // btnPause
                // 
                this.btnPause.Location = new System.Drawing.Point(697, 102);
                this.btnPause.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.btnPause.Name = "btnPause";
                this.btnPause.Size = new System.Drawing.Size(243, 36);
                this.btnPause.TabIndex = 1;
                this.btnPause.Text = "暂停游戏";
                this.btnPause.UseVisualStyleBackColor = true;
                this.btnPause.Click += new System.EventHandler(this.btnPause_Click);
                // 
                // btnReset
                // 
                this.btnReset.Location = new System.Drawing.Point(697, 218);
                this.btnReset.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.btnReset.Name = "btnReset";
                this.btnReset.Size = new System.Drawing.Size(243, 36);
                this.btnReset.TabIndex = 1;
                this.btnReset.Text = "重新排列";
                this.btnReset.UseVisualStyleBackColor = true;
                this.btnReset.Click += new System.EventHandler(this.btnReset_Click);
                // 
                // comboBox2
                // 
                this.comboBox2.FormattingEnabled = true;
                this.comboBox2.Location = new System.Drawing.Point(780, 367);
                this.comboBox2.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.comboBox2.Name = "comboBox2";
                this.comboBox2.Size = new System.Drawing.Size(160, 23);
                this.comboBox2.TabIndex = 5;
                // 
                // label1
                // 
                this.label1.AutoSize = true;
                this.label1.Location = new System.Drawing.Point(694, 321);
                this.label1.Name = "label1";
                this.label1.Size = new System.Drawing.Size(52, 15);
                this.label1.TabIndex = 6;
                this.label1.Text = "难度:";
                // 
                // label2
                // 
                this.label2.AutoSize = true;
                this.label2.Location = new System.Drawing.Point(694, 372);
                this.label2.Name = "label2";
                this.label2.Size = new System.Drawing.Size(52, 15);
                this.label2.TabIndex = 6;
                this.label2.Text = "模式:";
                // 
                // MainWindow
                // 
                this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 15F);
                this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
                this.BackgroundImage = ((System.Drawing.Image)(resources.GetObject("$this.BackgroundImage")));
                this.BackgroundImageLayout = System.Windows.Forms.ImageLayout.Stretch;
                this.ClientSize = new System.Drawing.Size(1008, 652);
                this.Controls.Add(this.label2);
                this.Controls.Add(this.label1);
                this.Controls.Add(this.comboBox2);
                this.Controls.Add(this.comboBox1);
                this.Controls.Add(this.lableScore);
                this.Controls.Add(this.lblTimeDelay);
                this.Controls.Add(this.pbTimeDelay);
                this.Controls.Add(this.btnReset);
                this.Controls.Add(this.btnPause);
                this.Controls.Add(this.btnStop);
                this.Controls.Add(this.btnStart);
                this.Controls.Add(this.TableLp);
                this.Margin = new System.Windows.Forms.Padding(3, 2, 3, 2);
                this.Name = "MainWindow";
                this.Text = "Form1";
                this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing);
                this.Load += new System.EventHandler(this.Form1_Load);
                this.ResumeLayout(false);
                this.PerformLayout();
    
            }
    
            #endregion
    
            private System.Windows.Forms.TableLayoutPanel TableLp;
            private System.Windows.Forms.Button btnStart;
            private System.Windows.Forms.ProgressBar pbTimeDelay;
            private System.Windows.Forms.Label lblTimeDelay;
            private System.Windows.Forms.Label lableScore;
            private System.Windows.Forms.Button btnStop;
            private System.Windows.Forms.ComboBox comboBox1;
            private System.Windows.Forms.Button btnPause;
            private System.Windows.Forms.Button btnReset;
            private System.Windows.Forms.ComboBox comboBox2;
            private System.Windows.Forms.Label label1;
            private System.Windows.Forms.Label label2;
        }
    }
    
    
    

    连连看功能类

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    
    namespace Linkup
    {
        // 连连看功能类
        public class LinkClass
        {
            // 连连看 看板
            public int[,] LinkBoard { get; set; }//命名为LinkBoard的连连看看板
    
            // 连线成功事件
            public event EventHandler SucClick;
            // 连接失败事件
            public event EventHandler FailClick;
    
            //Col是行
            private int col = 10;
            public int Col 
            {
                get
                {
                    return col;
                }
                set
                {
                    col = value;
                }
            }
    
            // Row是列
            private int row = 10;
            public int Row
            {
                get
                {
                    return row;
                }
                set
                {
                    row = value;
                }
            }
    
            // 连接测试函数
            public void LinkLine(Point first,Point second)//点击的第一个点为first;点击的第二个点为second
            {
                // EventArgs:事件参数
                EventArgs e = new EventArgs();
                if (checkLink(first, second))   // 判断是否连接成功
                {
                    // 连线成功
                    this.LinkBoard[first.X, first.Y] = 0;//清除记忆中的first,以便下一次消除
                    this.LinkBoard[second.X, second.Y] = 0;//清除记忆中的second,以便下一次消除
                    if (this.SucClick != null)  // 给事件添加事件参数
                    {
                        SucClick(this, e); 
                    }
                }
                else
                {
                    // 连线失败
                    if (this.FailClick != null)//给事件添加事件参数
                    {
                        FailClick(this, e);
                    }
                }
    
    
            }
    
            // 是否赋
            public bool IsChecked(Point p)
            {
                bool flag = false;
                if (p.X != -1 && p.Y != -1)
                {
                    flag = true;
                }
                return flag;
            }
    
    
            // 判断是否连接成功——核心算法
            /*
                a,第一个点   b,第二个点
             */
            private bool checkLink(Point a,Point b)
            {
                if (!Point.Equals(a,b)) // 如果点击的不是同一位置
                {
                    // 如果点击的不是同一位置
                    if (this.LinkBoard[a.X, a.Y] == this.LinkBoard[b.X, b.Y])//如果两者为同一图案
                    {
                        // 判断连线能否成功
                        if (a.X == b.X && vertical(a, b))//垂直
                        {
                            return true;
                        }
                        if (a.Y == b.Y && horizon(a, b))//水平
                        {
                            return true;
                        }
                        if (oneCorner(a, b))//一个拐点
                        {
                            return true;
                        }
                        else//两个拐点
                        {
                            return twoCorner(a, b);
                        }
                    }
                    else
                    {
                        // 如果点击的不是同一个图案,直接返回false
                        return false;
                    }
                }
                else
                {
                    // 如果点击的是同一个位置的图案,直接返回false;
                    return false;
                }
    
            }
    
    
            // 垂直的连线情况
            private bool vertical(Point a, Point b)
            {
                int col_start = a.Y < b.Y ? a.Y : b.Y;    //获取a,b中较小的y值
                int col_end = a.Y < b.Y ? b.Y : a.Y;      //获取a,b中较大的y值
    
                //遍历a,b之间是否通路,如果一个不是就返回false;
                for (int i = col_start + 1; i < col_end; i++)
                {
                    if (this.LinkBoard[a.X, i] != 0)//0是空的状态(即没有按钮)
                    {
                        return false;
                    }
                }
                return true;
            }
    
            // 水平的连线情况
            private bool horizon(Point a, Point b)
            {
                int row_start = a.X < b.X ? a.X : b.X;//获取a,b中较小的x值
                int row_end = a.X < b.X ? b.X : a.X;//获取a,b中较大的x值
                for (int i = row_start + 1; i < row_end; i++)
                {
                    if (this.LinkBoard[i, a.Y] != 0)//0是空的状态(即没有按钮)
                    {
                        return false;//return是函数结束
                    }
                }
                return true;
            }
    
            // 一个拐角连线情况
            private bool oneCorner(Point a, Point b)
            {
                // 拐角点的x,y分别等于两点各个x,y
                Point c = new Point(b.X, a.Y);
                Point d = new Point(a.X, b.Y);
                // 判断C点是否有元素,有就继续执行下面判断条件,没有就看a与c,b与c之间是否能水平或者垂直连线                
                if (this.LinkBoard[c.X, c.Y] == 0)
                {
                    bool path1 = vertical(b, c) && horizon(a, c);
                    return path1;   //path1本身就是bool值
                }
    
                //判断D点是否有元素
                if (this.LinkBoard[d.X, d.Y] == 0)
                {
                    bool path2 = vertical(a, d) && horizon(b, d);
                    return path2;//path2本身就是bool值
                }
                
                // 能执行到这就说明前面判断不成功,不存在一个拐点的情况
                return false;
               
            }
    
            // 两个拐点
            private bool twoCorner(Point a, Point b)
            {
                // list容器:相当于一个Line类型的数组,存扫到的连通路径
                List<Line> ll = scan(a, b);//此时的直线已经判断成功并且拐点位置没有数字
                if (ll.Count == 0)  // 没扫到返回false,List容器里面的计数方法
                {
                    return false;
                }
    
                for (int i = 0; i < ll.Count; i++)
                {
                    Line tempLine = ll[i];  // 临时连线变量用于判断拐点与a,b的通路是否成立
                    if (tempLine.direct == 1)   // 两个拐点之间是水平直连
                    {// 判断分别两个拐点与a,b能否相连
                        if (horizon(a, tempLine.a) && horizon(b, tempLine.b))//判断a与a"之间是否有通路;判断b与b"之间是否有通路
                        {
                            return true;
                        }
                    }
                    else if (tempLine.direct == 0)  // 两个拐点之间是垂直直连
                    {// 判断分别两个拐点与a,b能否相连
                        if (vertical(a, tempLine.a) && vertical(b, tempLine.b))//判断a与a"之间是否有通路;判断b与b"之间是否有通路
                        {
                            return true;
                        }
                    }
                }
                return false;
            }
    
            // 扫描A与B之间的连接点组成的线(scan)
            //List为容器
            private List<Line> scan(Point a, Point b)
            {
                List<Line> linkList = new List<Line>();// 新建一个直线对象List容器,用来存成立的拐点之间的直线
    
                //检测a点上方是否能够水平直连
                for (int i = a.Y; i >= 0; i--)
                {
                    if (this.LinkBoard[a.X, i] == 0 && this.LinkBoard[b.X, i] == 0 && horizon(new Point(a.X, i), new Point(b.X, i)))
                    {
                        linkList.Add(new Line(new Point(a.X, i), new Point(b.X, i), 0));
                    }
                }
    
                //检测a点下方是否能够水平直连
                for (int i = a.Y; i < Col; i++)
                {
                    if (this.LinkBoard[a.X, i] == 0 && this.LinkBoard[b.X, i] == 0 && horizon(new Point(a.X, i), new Point(b.X, i)))
                    {
                        linkList.Add(new Line(new Point(a.X, i), new Point(b.X, i), 0));
                    }
                }
    
                //检测a点左侧是否能够垂直直连
                for (int j = a.X; j >= 0; j--)
                {
                    if (this.LinkBoard[j, a.Y] == 0 && this.LinkBoard[j, b.Y] == 0 && vertical(new Point(j, a.Y), new Point(j, b.Y)))
                    {
                        linkList.Add(new Line(new Point(j, a.Y), new Point(j, b.Y), 1));
                    }
                }
    
                //检测a点右侧是否能够垂直直连
                for (int j = a.X; j < Row; j++)
                {
                    if (this.LinkBoard[j, a.Y] == 0 && this.LinkBoard[j, b.Y] == 0 && vertical(new Point(j, a.Y), new Point(j, b.Y)))
                    {
                        linkList.Add(new Line(new Point(j, a.Y), new Point(j, b.Y), 1));
    
                    }
                }
    
                return linkList;
            }
        }
    
        // 两个拐点之间构成连线类
        public class Line
        {
            public Point a;
            public Point b;
            public int direct; //连线方向———  1:水平直连   0:垂直直连
            public Line(Point a, Point b, int direct)//Line是个构造函数
            {
                this.a = a;
                this.b = b;
                this.direct = direct;
            }
    
        }
    }
    
    
    

    窗体功能实现

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace Linkup
    {
        public partial class MainWindow : Form
        {
            private int curDelay = 0;                           // 当前剩余时间
            private LinkClass LinkObj = new LinkClass();        // 连连看功能类对象(变量),以后在这对象层面上操作
            private Point first = new Point(-1, -1);            // 第一次点击的位置
            private Point second = new Point(-1, -1);           // 第二次点击的位置
            private int score = 0;                              // 分数
            private bool isClosing = false;                     // 界面是否关闭
    
            public MainWindow()
            {
                InitializeComponent();
    
                //以下采用双缓冲方式,减少闪烁
                this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
                this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
                this.SetStyle(ControlStyles.UserPaint, true);
    
                // 给该对象添加点击事件
                this.LinkObj.SucClick += Link_SucClick;
                this.LinkObj.FailClick += Link_FailClick;
            }
    
            private void Form1_Load(object sender, EventArgs e)
            {
                //在combox加载三种关卡
                comboBox1.Items.Add("8*8");
                comboBox1.Items.Add("10*10");
                comboBox1.Items.Add("12*12");
    
                comboBox2.Items.Add("图片");
                comboBox2.Items.Add("数字");
            }
    
            // 初始化连连看数组
            int hang = 0;   // 行列数
            private void InitLinkGameOne()
            {
                // 难度设置
                if (comboBox1.Text == ""|| comboBox2.Text=="")
                {
                    MessageBox.Show("请选择难度或者模式", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                else
                {
                    // 选择的关卡难度文本
                    string Diffcult = comboBox1.Text;
                    //根据对应难度初始化数组并给n赋值
                    switch (Diffcult)
                    {
                        case "8*8":
                            hang = 8;
                            break;
                        case "10*10":
                            hang = 10;
                            break;
                        case "12*12":
                            hang = 12;
                            break; 
                    }
    
                    // 用于产生不重复随机数
                    long tick = DateTime.Now.Ticks;
                    Random r = new Random((int)(tick & 0xffffffffL) | (int)(tick >> 32));
                    // 棋盘周围空出一圈0
                    int[,] linkBoard = new int[hang + 2, hang + 2];
                    this.LinkObj.Row = hang + 2;
                    this.LinkObj.Col = hang + 2;
    
                    // 将内置元素进行随机数分配等操作
                    for (int row = 1; row < hang + 1; row++)
                    {
                        for (int col = 1; col < (hang + 1)/2+1; col++)
                        {
                            int rnd;
                            switch (hang)
                            {
                                case 8:
                                    rnd = r.Next(1, 1000) % 13 + 1;//13种图
                                    break;
                                case 10:
                                    rnd = r.Next(1, 1000) % 15 + 1;//15种图
                                    break;
                                case 12:
                                    rnd = r.Next(1, 1000) % 17 + 1;//17种图
                                    break;
                                default:
                                    rnd = 0;
                                    break;
                            }
                            // n种图
    
                            string img = string.Format("_1_{0}", rnd.ToString("00"));//给图片命名
    
                            linkBoard[row, col] = rnd;                      // 赋给每个位置随机数字
                            linkBoard[row, (hang + 1) / 2 + col] = rnd;     // 赋给相对位置随机数字
                        }
                    }
                    this.LinkObj.LinkBoard = linkBoard;//初始化棋盘
                    this.TableLp.Enabled = false;
    
                    // 控件变量等初始化
                    this.btnStart.Enabled = false;
                    //设置时间以及按钮
                    this.curDelay = pbTimeDelay.Maximum;//让剩余时间为计时条的最大值
                    this.pbTimeDelay.Value = this.curDelay;//给进度条赋值
                    this.lblTimeDelay.Text = this.curDelay.ToString();//显示剩余时间
                    this.TableLp.Enabled = true;
                    score = 400;//计分
    
                    // 启动用多线程计时器函数
                    timeDelay = new Thread(timeDelay_Tick);
                    //ma.Set();
                    timeDelay.Start();  //启动定时器线程
                }
    
            }
    
            // 获取图片名
            internal static Bitmap GetImageByName(string name)
            {
                // 全局资源搜索
                object obj = global::Linkup.Properties.Resources.ResourceManager.GetObject(name, global::Linkup.Properties.Resources.Culture);
                return ((Bitmap)(obj));
            }
    
            // 打乱顺序函数
            private void Reset()
            {
                //设置tableLayoutPanel的列数和行数
                this.TableLp.ColumnCount = hang + 2;
                this.TableLp.RowCount = hang + 2;
                // 清除残余属性
                this.TableLp.ColumnStyles.Clear();
                this.TableLp.RowStyles.Clear();
                this.TableLp.Controls.Clear();
    
                for (int i = 0; i < hang + 2; i++)
                {
                    //设置等宽等高  边缘2,里面内容10
                    if (i == 0 || i == hang + 1)
                    {
                        this.TableLp.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 2));
                        this.TableLp.RowStyles.Add(new RowStyle(SizeType.Percent, 2));
                    }
                    else
                    {
                        this.TableLp.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 10));
                        this.TableLp.RowStyles.Add(new RowStyle(SizeType.Percent, 10));
                    }
                }
                this.TableLp.Padding = new Padding(1);//约束控件内边距
                this.TableLp.CellBorderStyle = TableLayoutPanelCellBorderStyle.None;    // 不显示边框线
                long tick = DateTime.Now.Ticks;
                // 用于产生不重复随机数
                Random r = new Random((int)(tick & 0xffffffffL) | (int)(tick >> 32));
    
                int[,] linkBoard = new int[hang + 2, hang + 2];
    
                linkBoard = this.LinkObj.LinkBoard;//将这个对象的数组值赋给这个变量,便于操作
                                                   // 将内置元素进行随机贴图等操作
                int rnd, rnd2;
                // 打乱二维数组顺序
                for (int row = 1; row < hang + 1; row++)
                {
                    for (int col = 1; col < hang + 1; col++)
                    {
                        // 产生随机数
                        rnd = r.Next(1, 1000) % hang + 1;
                        rnd2 = r.Next(1, 1000) % hang + 1;
    
                        int temp = linkBoard[rnd, rnd2];
                        linkBoard[rnd, rnd2] = linkBoard[row, col];
                        linkBoard[row, col] = temp;
    
                    }
                }
                this.LinkObj.LinkBoard = linkBoard;//初始化棋盘
    
                for (int row = 1; row < hang + 1; row++)
                {
                    for (int col = 1; col < hang + 1; col++)
                    {
                        if (linkBoard[row, col] != 0)
                        {
                            if (comboBox2.Text=="图片")
                            {
                                string img = string.Format("_1_{0}", linkBoard[row, col].ToString("00"));//给图片命名
                                Button btnLinker = new Button() // 设置每个小按钮的相关属性
                                {
                                    BackgroundImage = GetImageByName(img),//给按钮填充背景图片
                                                                          //Text = rnd.ToString(),
                                    BackgroundImageLayout = ImageLayout.Stretch,//背景图片拉伸
                                    Tag = img,//标签
                                    Name = string.Format("{0},{1}", row, col),//将按钮的名字分成为x,y
                                    Dock = DockStyle.Fill,//调整控件的层次,填充
                                    Margin = new Padding(1),//调整外边距
                                };
                                btnLinker.Click += BtnLinker_Click; // 让每个按钮都拥有点击事件
                                this.TableLp.Controls.Add(btnLinker, col, row);
                            }
                            else
                            {
                                string img = string.Format("_1_{0}", linkBoard[row, col].ToString("00"));//给图片命名
                                Button btnLinker = new Button() // 设置每个小按钮的相关属性
                                {
                                    Text = linkBoard[row, col].ToString(),
                                    Tag = img,//标签
                                    Name = string.Format("{0},{1}", row, col),//将按钮的名字分成为x,y
                                    Dock = DockStyle.Fill,//调整控件的层次,填充
                                    Margin = new Padding(1),//调整外边距
                                };
                                btnLinker.Click += BtnLinker_Click; // 让每个按钮都拥有点击事件
                                this.TableLp.Controls.Add(btnLinker, col, row);
                            }
                            
                        }
                    }
                }
    
                score -= 400;
                lableScore.Text = "分数:" + score.ToString();
            }
    
            // 判断成功
            private void Judge()
            {
                int count=0;
                // 将内置元素进行随机数分配等操作
                for (int row = 1; row < hang + 1; row++)
                {
                    for (int col = 1; col < hang + 1; col++)
                    {
                        if (this.LinkObj.LinkBoard[row,col]==0)
                        {
                            count++;
                        }
                    }
                }
                if (count==hang*hang)
                {
                    MessageBox.Show("拼完了,你可真厉害!","提示",MessageBoxButtons.OK,MessageBoxIcon.Asterisk);
                    this.TableLp.Enabled = false;
                    btnStart.Enabled = true;
    
                    timetemp = this.curDelay;
                    this.curDelay = 0;
                    lblTimeDelay.Text = timetemp.ToString();
                }
            }
    
            // 事件
            // 每个小图片按钮单击事件
            private void BtnLinker_Click(object sender, EventArgs e)
            {
                Button btnLinker = (Button)sender;                  // 事件参数
                btnLinker.FlatStyle = FlatStyle.Flat;               // 决定按钮的外观
                btnLinker.FlatAppearance.BorderColor = Color.Red;   // 按钮外边框颜色
                btnLinker.FlatAppearance.BorderSize = 2;            // 按钮外边框的大小
                string[] loc = btnLinker.Name.Split(',');           // 将按钮的名字分成x,y
                if (!LinkObj.IsChecked(first))                      // 第一次点给第一个点赋值
                {
                    first = new Point(int.Parse(loc[0]), int.Parse(loc[1]));
                }
                else// 第二次点给第二个参数赋值
                {
                    second = new Point(int.Parse(loc[0]), int.Parse(loc[1]));
                    // 如果就第二次点击,则进行判断
                    LinkObj.LinkLine(first, second);
                }
            }
    
            // 计时器线程
            Thread timeDelay;       // 线程变量
            int timetemp = 0;       // 计时器中间变量
    
            // 开始按钮事件
            private void btnStart_Click(object sender, EventArgs e)
            {
                if (btnStart.Text=="开始游戏")
                {
                    // 先初始化连连看板
                    InitLinkGameOne();
                    // 打乱顺序
                    Reset();
                }
                else if (btnStart.Text == "继续游戏")
                {
                    //ma.Set();//信号打开,不阻塞当前线程
                    btnStart.Text = "开始游戏";
                    btnStart.Enabled = false;
                    this.TableLp.Enabled = true;
                    this.curDelay= timetemp;// 将中间变量赋值给新的当前时间
                    lblTimeDelay.Text = this.curDelay.ToString();
                    timeDelay = new Thread(new ThreadStart(this.timeDelay_Tick));//新的计时器
                    timeDelay.Start();
                }
                
            }
    
            // 结束按钮
            private void btnStop_Click(object sender, EventArgs e)
            {
                this.curDelay = 0;
                Thread.Sleep(100);
                btnStart.Text = "开始游戏";
            }
    
            // 重新排列
            private void btnReset_Click(object sender, EventArgs e)
            {
                // 扣分
                if (score<= -400)
                {
                    MessageBox.Show("你已经负债累累,不能再扣分了!","提示",MessageBoxButtons.OK,MessageBoxIcon.Stop);
                }
                else
                {
                    Reset();
                }
            }
    
            // 暂停按钮
            private void btnPause_Click(object sender, EventArgs e)
            {
                this.TableLp.Enabled = false;
      
                btnStart.Enabled = true;
                btnStart.Text = "继续游戏";
    
                timetemp = this.curDelay;
                this.curDelay = 0;
                lblTimeDelay.Text = timetemp.ToString();
            }
    
            // 定时器事件:时间剩余
            void timeDelay_Tick()
            {
                //ma.WaitOne(); // 根据是否收到信号判断是否阻塞当前线程
                while (this.curDelay > 0 )   // 当前时间大于零
                {
                    if (!isClosing)
                    {
                        this.curDelay--;
                        this.pbTimeDelay.Value = this.curDelay;
                        this.lblTimeDelay.Text = this.curDelay.ToString();
                        
                    }
                    Thread.Sleep(1000);
                }
                if (!isClosing)
                {
                  
                    this.btnStart.Enabled = true;
                    this.TableLp.Enabled = false;
                  
                }
            }
    
            // 连接成功事件
            private void Link_SucClick(object sender, EventArgs e)
            {
                //连接成功,则删除,重新初始化
                this.TableLp.GetControlFromPosition(this.first.Y, this.first.X).Visible = false;//第一块消失
                this.TableLp.GetControlFromPosition(this.second.Y, this.second.X).Visible = false;//第二块消失
                this.first = new Point(-1, -1);//初始化第一块的位置
                this.second = new Point(-1, -1);//初始化第一块的位置
                this.score += 100;  
                this.lableScore.Text = string.Format("分数:{0}", score);
    
                // 消除成功加时,保证进度条不会消失
                if (curDelay <= 98)
                {
                    curDelay += 2;
                }
                else if (curDelay == 99)
                {
                    curDelay += 1;
                }
                // 判断是否连完
                Judge();
            }
    
            // 连接失败事件
            private void Link_FailClick(object sender, EventArgs e)
            {
                //连接失败,则第一个按钮取消选择
                Control c1 = this.TableLp.GetControlFromPosition(this.first.Y, this.first.X);
                ((Button)c1).FlatAppearance.BorderSize = 0;//第一块的外边框消失
                this.first = new Point(this.second.X, this.second.Y);
                this.second = new Point(-1, -1);
            }
    
            // 界面关闭事件
            private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
            {
                this.isClosing = true;
                this.btnStop_Click(null, null);
                // 界面关闭,终止线程
                if (this.timeDelay != null && this.timeDelay.ThreadState == ThreadState.Running)
                {
                    this.timeDelay.Abort();
                }
            }
        }
    }
    
    
    展开全文
  • 一个简单的五子棋游戏,具有判定输赢、悔棋、重新开始等功能。简单的demo,可以自己完善,欢迎提BUG! (¦3[▓▓]
  • 使用面向对象的思想(继承和派生),并借助窗体重载OnPaint方法实现飞机、子弹、爆炸的绘制效果。代码中使用大量注释,以帮助读者更好的理解代码 打开游戏后,回车即可开始游戏,上下左右键 用于 控制战机方向
  • C#窗体切换特效

    2016-11-02 15:00:26
    最全面的C#窗体切换特效,内含 水平翻转、垂直翻转、透明过渡、水平盒子、垂直盒子、多洛米、里.水平 、里.垂直、盒子乱舞、水平交错、垂直交错、水平移动、垂直移动等等特效。
  • C#窗体程序编写 • 【五子棋】

    千次阅读 多人点赞 2021-03-07 23:10:00
    C#窗体编写的五子棋、每一步都有注释,放心学习。如果有代码逻辑不懂,可以联系我(会看) 末尾提供全部代码(去掉注释,代码其实很少,这就要归功于C#窗体的方便) 第一步.窗体界面 拖控件:拖两个 panel(面板)...

    C#窗体编写的五子棋、每一步都有注释

    末尾提供全部代码(去掉注释,代码其实很少,C#窗体真方便!)

    第一步.窗体界面

    在这里插入图片描述

    拖控件:拖两个 panel(面板)控件,三个 button(按钮)控件,一个 label(标签)控件

    设属性:为一个 panel 控件的 Dock属性选择 Fill(填满),另一个选择 right(右侧)。其他属性 如背景颜色根据喜好设置

    三个按钮的Text,分别设置为 开始游戏、重新开始、退出

    label用来提示游戏状态,如白子回合还是黑子回合

    第二步.私有成员,窗体 Load(加载)事件,和 初始化游戏 方法

    	// 窗体程序
        public partial class Form1 : Form
        {
            private bool start;     // 游戏是否开始
    
            private bool ChessCheck = true;     // 白子黑子回合
    
            private const int size = 15;     // 棋盘大小
    
            private int[,] CheckBoard = new int[size, size];     // 棋盘点位数组
    
            public Form1()
            {
                InitializeComponent();
            }
    
            // "窗口"Load事件
            private void Form1_Load(object sender, EventArgs e)
            {
                initializeGame();                      // 调用初始化游戏
                this.Width = MainSize.FormWidth;       // 设置窗口宽度
                this.Height = MainSize.FormHeight;     // 设置窗口高度
                this.Location = new Point(400,75);     // 设置窗口位置
            }
    
            // 初始化游戏
            private void initializeGame()
            {
                // 棋盘点位数组 重置为0
                for (int i = 0; i < size; i++)
                {
                    for (int j = 0; j < size; j++)
                    {
                        CheckBoard[i, j] = 0;
                    }
                }
                start = false;                         // 未开始
                label1.Text = "游戏未开始";            // 提示文本改为"游戏未开始"
                button1.Visible = true;                // 显示'开始游戏'按钮
                button4.Visible = false;               // 隐藏'重新开始'按钮
            }
    

    第三步.MainSize类(用来说明 窗口大小、棋盘大小等)

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace day11_01
    {
        // 成员大小类
        class MainSize
        {
            // 窗口大小
            public static int FormWidth { get { return 710; } }
            public static int FormHeight { get { return 640; } }
    
            // 棋盘大小
            public static int CBoardWidth { get { return 600; } }
            public static int CBoardHeight { get { return 600; } }
    
            // 棋格宽度
            public static int CBoardGap { get { return 40; } }
    
            // 棋子直径
            public static int ChessDiameter { get { return 37; } }
        }
    }
    
    

    第四步.ChessBoard棋盘类(用来 画棋盘)

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    
    namespace day11_01
    {
        // 棋盘类
        class ChessBoard
        {
            // 画棋盘方法
            public static void DrawCB(Graphics g)  //这里的形参,是画布对象
            {
                int GapWidth = MainSize.CBoardGap;                   // 棋格宽度
                int GapNum = MainSize.CBoardWidth / GapWidth - 1;    // 棋格数量
    
                Bitmap image = new Bitmap("D:\\C语言\\代码\\day11\\day11_01_image\\CheckBoard1.png"); // 棋盘位图路径
                g.DrawImage(image, new Point[] { new Point(0, 0), new Point(GapWidth * GapNum + 44, 0), new Point(0, GapWidth * GapNum + 44) }); // 画棋盘图片
    
    
                /* 这个是 没有用棋盘图片时,用的“画笔”画棋盘方法
                g.Clear(Color.Bisque);                               // 清除画布、并用Bisque颜色填满画布
                Pen pen = new Pen(Color.FromArgb(192, 166, 107));    // 实例化画笔
                // 画棋盘
                for (int i = 0; i < GapNum + 1; i++)
                {
                    g.DrawLine(pen, new Point(20, i * GapWidth + 20), new Point(GapWidth * GapNum + 20, i * GapWidth + 20));
                    g.DrawLine(pen, new Point(i * GapWidth + 20, 20), new Point(i * GapWidth + 20, GapWidth * GapNum + 20));
                }
                */
            }
        }
    }
    
    

    第五步.Chess棋子类(用来画鼠标点击处的棋子、且页面重新聚集时,重新加载之前的棋子)

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    using System.Windows.Forms;
    using System.Drawing.Drawing2D;     // 使支持渐变画刷
    
    namespace day11_01
    {
        // 棋子类
        class Chess
        {
            // 画棋子
            public static void DrawC(Panel p, bool ChessCheck, int PlacementX, int PlacementY)
            {
                Graphics g = p.CreateGraphics();                // 创建面板画布
    
                int AccurateX = PlacementX * MainSize.CBoardGap + 20 - 17; // 精确棋子的X中心位置
                int AccurateY = PlacementY * MainSize.CBoardGap + 20 - 17; // 精确棋子的Y中心位置
    
                // 判断谁的回合并画棋子
                if (ChessCheck)
                {
                	// 线性渐变会平铺整个面板,根据你的位置填颜色,从上至下渐变,使棋子具有真实感
                    g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(122, 122, 122), Color.FromArgb(0, 0, 0)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter))); 
                }
                else
                {
                    g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(255, 255, 255), Color.FromArgb(204, 204, 204)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                }
            }
    
            // 界面重新聚焦时,重新加载棋子
            public static void ReDrawC(Panel p,int[,] CheckBoard)
            {
                Graphics g = p.CreateGraphics();                // 创建面板画布
    
                // 遍历 获取棋盘数组的每行
                for (int i = 0; i < CheckBoard.GetLength(1); i++)
                {
                    // 遍历 获取棋盘数组每行的每列
                    for (int j = 0; j < CheckBoard.GetLength(0); j++)
                    {
                        int Judgment = CheckBoard[j, i];        // 判断数组当前行列,白子还是黑子回合,0表示没有,1表示黑子,2表示白子
    
                        // 判断是否有棋子
                        if (Judgment != 0)
                        {
                            int AccurateX = j * MainSize.CBoardGap + 20 - 17; // 精确棋子的X中心位置
                            int AccurateY = i * MainSize.CBoardGap + 20 - 17; // 精确棋子的Y中心位置
    
                            // 判断谁的回合并画棋子
                            if (Judgment == 1)
                            {
                            	// 线性渐变会平铺整个面板,根据你的位置填颜色,从上至下渐变,使棋子具有真实感
                                g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(122, 122, 122), Color.FromArgb(0, 0, 0)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                            }
                            else
                            {
                                g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(255, 255, 255), Color.FromArgb(204, 204, 204)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                            }
                        }
                    }
                }
            }
        }
    }
    
    

    第六步.两个 panel(面板)的Paint(重绘窗体时发生)事件(分别代表棋盘,和控制界面)

    		// 面板"棋盘"Paint事件
            private void panel1_Paint(object sender, PaintEventArgs e)
            {
                Graphics g = panel1.CreateGraphics();      // 创建面板画布
                ChessBoard.DrawCB(g);                      // 调用画棋盘方法
                Chess.ReDrawC(panel1, CheckBoard);         // 调用重新加载棋子方法
            }
    
            // 面板"控制界面"Paint事件
            private void panel2_Paint(object sender, PaintEventArgs e)
            {
                // 设置控制界面的大小
                panel2.Size = new Size(MainSize.FormWidth - MainSize.CBoardWidth - 20, MainSize.FormHeight);
            }
    

    第七步.三个按钮 Click(点击)事件(开始游戏、重新开始、退出)

    		// 按钮"开始游戏"CLick事件
            private void button1_Click(object sender, EventArgs e)
            {
                start = true;                              // 开始
                ChessCheck = true;                         // 黑子回合
                label1.Text = "黑子回合";                  // 提示文本改为"黑子回合"
                button1.Visible = false;                   // 隐藏'开始游戏'按钮
                button4.Visible = true;                    // 显示'重新开始'按钮
                panel1.Invalidate();                       // 重绘面板"棋盘"
            }
    
            // 按钮"重新开始"CLick事件
            private void button4_Click(object sender, EventArgs e)
            {
                // 确认是否重新开始
                if (MessageBox.Show("确认要重新开始?", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.OK)
                {
                    initializeGame();                      // 调用初始化游戏方法
                    button1_Click(sender, e);              // 调用按钮"开始游戏"Click事件
                }
            }
    
            // 按钮"退出"CLick事件
            private void button5_Click(object sender, EventArgs e)
            {
                this.Dispose();                            // 退出窗口
            }
    

    第八步.面板 “棋盘” 的 MouseDown(鼠标点击)事件(在点击位置画棋子)

    		// 面板"棋盘"MouseDown事件
            private void panel1_MouseDown(object sender, MouseEventArgs e)
            {
                // 判断游戏是否开始
                if (start)
                {
                    int Judgment = 0;            // 判断数组当前行列,白子还是黑子回合,0表示没有,1表示黑子,2表示白子、用来判断胜利
    
                    int PlacementX = e.X / MainSize.CBoardGap;      // 求鼠标点击的X方向的第几个点位
                    int PlacementY = e.Y / MainSize.CBoardGap;      // 求鼠标点击的Y方向的第几个点位
    
                    try
                    {
                        // 判断此位置是否为空
                        if (CheckBoard[PlacementX, PlacementY] != 0)
                        {
                            return;                                 // 此位置有棋子
                        }
    
                        // 黑子回合还是白子回合
                        if (ChessCheck)
                        {
                            CheckBoard[PlacementX, PlacementY] = 1; // 黑子回合
                            Judgment = 1;                           // 切换为判断黑子
                            label1.Text = "白子回合";               // 提示文本改为"白子回合"
                        }
                        else
                        {
                            CheckBoard[PlacementX, PlacementY] = 2; // 白子回合
                            Judgment = 2;                           // 切换为判断白子
                            label1.Text = "黑子回合";               // 提示文本改为"黑子回合"
                        }
    
                        Chess.DrawC(panel1, ChessCheck, PlacementX, PlacementY);  // 画棋子
    
                        // 胜利判断
                        if (WinJudgment.ChessJudgment(CheckBoard, Judgment))
                        {
                            // 判断黑子还是白子胜利
                            if (Judgment == 1)
                            {
                                MessageBox.Show("五连珠,黑胜!", "胜利提示");    // 提示黑胜
                            }
                            else
                            {
                                MessageBox.Show("五连珠,白胜!", "胜利提示");    // 提示白胜
                            }
                            initializeGame();                      // 调用初始化游戏
                        }
    
                        ChessCheck = !ChessCheck;                   // 换棋子
                    }
                    catch(Exception) { }                            // 防止鼠标点击边界,导致数组越界
                    
                }
                else
                {
                    MessageBox.Show("请先开始游戏!", "提示");      // 提示开始游戏
                }
            }
    

    第九步.WinJudgment胜利判断类(用来判断胜利)

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace day11_01
    {
        // 胜利判断
        class WinJudgment
        {
            // 棋子判断
            public static bool ChessJudgment(int[,] CheckBoard, int Judgment)
            {
                bool Win = false;         // 胜利判断
    
                // 遍历 获取棋盘数组的每行
                for (int i = 0; i < CheckBoard.GetLength(1); i++)
                {
                    // 遍历 获取棋盘数组每行的每列
                    for (int j = 0; j < CheckBoard.GetLength(0); j++)
                    {
                        // 判断是否有棋子
                        if (CheckBoard[j, i] == Judgment)
                        {
                            // 水平判断
                            if (j < 11)
                            {
                                if (CheckBoard[j + 1, i] == Judgment && CheckBoard[j + 2, i] == Judgment && CheckBoard[j + 3, i] == Judgment && CheckBoard[j + 4, i] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                            // 垂直判断
                            if (i < 11)
                            {
                                if (CheckBoard[j, i + 1] == Judgment && CheckBoard[j, i + 2] == Judgment && CheckBoard[j, i + 3] == Judgment && CheckBoard[j, i + 4] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                            // 右下判断
                            if (j < 11 && i < 11)
                            {
                                if (CheckBoard[j + 1, i + 1] == Judgment && CheckBoard[j + 2, i + 2] == Judgment && CheckBoard[j + 3, i + 3] == Judgment && CheckBoard[j + 4, i + 4] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                            // 左下判断
                            if (j > 3 && i < 11)
                            {
                                if (CheckBoard[j - 1, i + 1] == Judgment && CheckBoard[j - 2, i + 2] == Judgment && CheckBoard[j - 3, i + 3] == Judgment && CheckBoard[j - 4, i + 4] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                        }
                    }
                }
                return Win;
            }
        }
    }
    
    

    运行效果

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    全部源码

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace day11_01
    {
        // 窗体程序
        public partial class Form1 : Form
        {
            private bool start;     // 游戏是否开始
    
            private bool ChessCheck = true;     // 白子黑子回合
    
            private const int size = 15;     // 棋盘大小
    
            private int[,] CheckBoard = new int[size, size];     // 棋盘点位数组
    
            public Form1()
            {
                InitializeComponent();
            }
    
            // "窗口"Load事件
            private void Form1_Load(object sender, EventArgs e)
            {
                initializeGame();                      // 调用初始化游戏
                this.Width = MainSize.FormWidth;       // 设置窗口宽度
                this.Height = MainSize.FormHeight;     // 设置窗口高度
                this.Location = new Point(400,75);     // 设置窗口位置
            }
    
            // 初始化游戏
            private void initializeGame()
            {
                // 棋盘点位数组 重置为0
                for (int i = 0; i < size; i++)
                {
                    for (int j = 0; j < size; j++)
                    {
                        CheckBoard[i, j] = 0;
                    }
                }
                start = false;                         // 未开始
                label1.Text = "游戏未开始";            // 提示文本改为"游戏未开始"
                button1.Visible = true;                // 显示'开始游戏'按钮
                button4.Visible = false;               // 隐藏'重新开始'按钮
            }
    
            // 按钮"开始游戏"CLick事件
            private void button1_Click(object sender, EventArgs e)
            {
                start = true;                              // 开始
                ChessCheck = true;                         // 黑子回合
                label1.Text = "黑子回合";                  // 提示文本改为"黑子回合"
                button1.Visible = false;                   // 隐藏'开始游戏'按钮
                button4.Visible = true;                    // 显示'重新开始'按钮
                panel1.Invalidate();                       // 重绘面板"棋盘"
            }
    
            // 按钮"重新开始"CLick事件
            private void button4_Click(object sender, EventArgs e)
            {
                // 确认是否重新开始
                if (MessageBox.Show("确认要重新开始?", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2) == DialogResult.OK)
                {
                    initializeGame();                      // 调用初始化游戏方法
                    button1_Click(sender, e);              // 调用按钮"开始游戏"Click事件
                }
            }
    
            // 按钮"退出"CLick事件
            private void button5_Click(object sender, EventArgs e)
            {
                this.Dispose();                            // 退出窗口
            }
    
            // 面板"棋盘"Paint事件
            private void panel1_Paint(object sender, PaintEventArgs e)
            {
                Graphics g = panel1.CreateGraphics();      // 创建面板画布
                ChessBoard.DrawCB(g);                      // 调用画棋盘方法
                Chess.ReDrawC(panel1, CheckBoard);         // 调用重新加载棋子方法
            }
    
            // 面板"控制界面"Paint事件
            private void panel2_Paint(object sender, PaintEventArgs e)
            {
                // 设置控制界面的大小
                panel2.Size = new Size(MainSize.FormWidth - MainSize.CBoardWidth - 20, MainSize.FormHeight);
            }
    
            // 面板"棋盘"MouseDown事件
            private void panel1_MouseDown(object sender, MouseEventArgs e)
            {
                // 判断游戏是否开始
                if (start)
                {
                    int Judgment = 0;            // 判断数组当前行列,白子还是黑子回合,0表示没有,1表示黑子,2表示白子、用来判断胜利
    
                    int PlacementX = e.X / MainSize.CBoardGap;      // 求鼠标点击的X方向的第几个点位
                    int PlacementY = e.Y / MainSize.CBoardGap;      // 求鼠标点击的Y方向的第几个点位
    
                    try
                    {
                        // 判断此位置是否为空
                        if (CheckBoard[PlacementX, PlacementY] != 0)
                        {
                            return;                                 // 此位置有棋子
                        }
    
                        // 黑子回合还是白子回合
                        if (ChessCheck)
                        {
                            CheckBoard[PlacementX, PlacementY] = 1; // 黑子回合
                            Judgment = 1;                           // 切换为判断黑子
                            label1.Text = "白子回合";               // 提示文本改为"白子回合"
                        }
                        else
                        {
                            CheckBoard[PlacementX, PlacementY] = 2; // 白子回合
                            Judgment = 2;                           // 切换为判断白子
                            label1.Text = "黑子回合";               // 提示文本改为"黑子回合"
                        }
    
                        Chess.DrawC(panel1, ChessCheck, PlacementX, PlacementY);  // 画棋子
    
                        // 胜利判断
                        if (WinJudgment.ChessJudgment(CheckBoard, Judgment))
                        {
                            // 判断黑子还是白子胜利
                            if (Judgment == 1)
                            {
                                MessageBox.Show("五连珠,黑胜!", "胜利提示");    // 提示黑胜
                            }
                            else
                            {
                                MessageBox.Show("五连珠,白胜!", "胜利提示");    // 提示白胜
                            }
                            initializeGame();                      // 调用初始化游戏
                        }
    
                        ChessCheck = !ChessCheck;                   // 换棋子
                    }
                    catch(Exception) { }                            // 防止鼠标点击边界,导致数组越界
                    
                }
                else
                {
                    MessageBox.Show("请先开始游戏!", "提示");      // 提示开始游戏
                }
            }
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace day11_01
    {
        // 成员大小类
        class MainSize
        {
            // 窗口大小
            public static int FormWidth { get { return 710; } }
            public static int FormHeight { get { return 640; } }
    
            // 棋盘大小
            public static int CBoardWidth { get { return 600; } }
            public static int CBoardHeight { get { return 600; } }
    
            // 棋格宽度
            public static int CBoardGap { get { return 40; } }
    
            // 棋子直径
            public static int ChessDiameter { get { return 37; } }
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    
    namespace day11_01
    {
        // 棋盘类
        class ChessBoard
        {
            // 画棋盘方法
            public static void DrawCB(Graphics g)
            {
                int GapWidth = MainSize.CBoardGap;                   // 棋格宽度
                int GapNum = MainSize.CBoardWidth / GapWidth - 1;    // 棋格数量
    
                Bitmap image = new Bitmap("D:\\C语言\\代码\\day11\\day11_01_image\\CheckBoard1.png"); // 棋盘位图路径
    
                g.DrawImage(image, new Point[] { new Point(0, 0), new Point(GapWidth * GapNum + 44, 0), new Point(0, GapWidth * GapNum + 44) }); // 画棋盘图片
    
                /*
                Pen pen = new Pen(Color.FromArgb(192, 166, 107));    // 实例化画笔
                // 画棋盘
                for (int i = 0; i < GapNum + 1; i++)
                {
                    g.DrawLine(pen, new Point(20, i * GapWidth + 20), new Point(GapWidth * GapNum + 20, i * GapWidth + 20));
                    g.DrawLine(pen, new Point(i * GapWidth + 20, 20), new Point(i * GapWidth + 20, GapWidth * GapNum + 20));
                }
                */
            }
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Drawing;
    using System.Windows.Forms;
    using System.Drawing.Drawing2D;
    
    namespace day11_01
    {
        // 棋子类
        class Chess
        {
            // 画棋子
            public static void DrawC(Panel p, bool ChessCheck, int PlacementX, int PlacementY)
            {
                Graphics g = p.CreateGraphics();                // 创建面板画布
    
                int AccurateX = PlacementX * MainSize.CBoardGap + 20 - 17; // 精确棋子的X中心位置
                int AccurateY = PlacementY * MainSize.CBoardGap + 20 - 17; // 精确棋子的Y中心位置
    
                // 判断谁的回合并画棋子
                if (ChessCheck)
                {
                    // 线性渐变会平铺整个面板,根据你的位置填颜色,从上至下渐变,使棋子具有真实感
                    g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(122, 122, 122), Color.FromArgb(0, 0, 0)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                }
                else
                {
                    g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(255, 255, 255), Color.FromArgb(204, 204, 204)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                }
            }
    
            // 界面重新聚焦时,重新加载棋子
            public static void ReDrawC(Panel p,int[,] CheckBoard)
            {
                Graphics g = p.CreateGraphics();                // 创建面板画布
    
                // 遍历 获取棋盘数组的每行
                for (int i = 0; i < CheckBoard.GetLength(1); i++)
                {
                    // 遍历 获取棋盘数组每行的每列
                    for (int j = 0; j < CheckBoard.GetLength(0); j++)
                    {
                        int Judgment = CheckBoard[j, i];        // 判断数组当前行列,白子还是黑子回合,0表示没有,1表示黑子,2表示白子
    
                        // 判断是否有棋子
                        if (Judgment != 0)
                        {
                            int AccurateX = j * MainSize.CBoardGap + 20 - 17; // 精确棋子的X中心位置
                            int AccurateY = i * MainSize.CBoardGap + 20 - 17; // 精确棋子的Y中心位置
    
                            // 判断谁的回合并画棋子
                            if (Judgment == 1)
                            {
                                g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(122, 122, 122), Color.FromArgb(0, 0, 0)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                            }
                            else
                            {
                                g.FillEllipse(new LinearGradientBrush(new Point(20, 0), new Point(20, 40), Color.FromArgb(255, 255, 255), Color.FromArgb(204, 204, 204)), new Rectangle(new Point(AccurateX, AccurateY), new Size(MainSize.ChessDiameter, MainSize.ChessDiameter)));
                            }
                        }
                    }
                }
            }
        }
    }
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace day11_01
    {
        // 胜利判断
        class WinJudgment
        {
            // 棋子判断
            public static bool ChessJudgment(int[,] CheckBoard, int Judgment)
            {
                bool Win = false;         // 胜利判断
    
                // 遍历 获取棋盘数组的每行
                for (int i = 0; i < CheckBoard.GetLength(1); i++)
                {
                    // 遍历 获取棋盘数组每行的每列
                    for (int j = 0; j < CheckBoard.GetLength(0); j++)
                    {
                        // 判断是否有棋子
                        if (CheckBoard[j, i] == Judgment)
                        {
                            // 水平判断
                            if (j < 11)
                            {
                                if (CheckBoard[j + 1, i] == Judgment && CheckBoard[j + 2, i] == Judgment && CheckBoard[j + 3, i] == Judgment && CheckBoard[j + 4, i] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                            // 垂直判断
                            if (i < 11)
                            {
                                if (CheckBoard[j, i + 1] == Judgment && CheckBoard[j, i + 2] == Judgment && CheckBoard[j, i + 3] == Judgment && CheckBoard[j, i + 4] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                            // 右下判断
                            if (j < 11 && i < 11)
                            {
                                if (CheckBoard[j + 1, i + 1] == Judgment && CheckBoard[j + 2, i + 2] == Judgment && CheckBoard[j + 3, i + 3] == Judgment && CheckBoard[j + 4, i + 4] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                            // 左下判断
                            if (j > 3 && i < 11)
                            {
                                if (CheckBoard[j - 1, i + 1] == Judgment && CheckBoard[j - 2, i + 2] == Judgment && CheckBoard[j - 3, i + 3] == Judgment && CheckBoard[j - 4, i + 4] == Judgment)
                                {
                                    return Win = true;
                                }
                            }
                        }
                    }
                }
                return Win;
            }
        }
    }
    
    
    参考自:

    https://blog.csdn.net/lfy905805357/article/details/81123656

    .

    新加了 悔棋棋盘下满 时的判断!
    https://blog.csdn.net/qq_51756226/article/details/117604992

    .

    视频手把手教:

    https://www.bilibili.com/video/BV1Kf4y1Y7ct

    展开全文
  • C# 窗体连连看(注释详细)
  • 标准数独的C#窗体应用程序,详细的脚本注释,完整的数独游戏
  • 值得一看的小游戏,比较有意思的C#小程序,源码通俗易懂,适合初学者小白,是个压缩包,适合展示给授课老师看。
  • C#窗体应用小例子

    2014-05-31 19:58:35
    C#窗体应用例子,有两个,一个是按上下左右键移动小球,第二个是委托的实例,创建一个发布者和两个接受者,在发布者的窗口里移动鼠标,接受者显示前十坐标的变化,还有一个接受者显示发布者的轨迹。
  • visual studio 2019 Windows窗体应用小游戏 贪吃蛇,适合初学者理解,程序注释里有我的自己对于贪吃蛇游戏思路的理解分析
  • C#窗体小程序

    2012-03-13 15:30:34
    这个程序用C#语言编写,有全部源代码,通过类和对象显示从窗体的程序。
  • C#窗体全屏功能

    千次阅读 2018-06-27 14:13:53
    C#窗体全屏功能C#应用程序中如何实现全屏幕显示功能? 效果就像windows自带的屏幕保护程序和众多的游戏那样,无论是否设置了“将任务栏保持在其他窗口的前端”都不显示任务栏实现方式一在网上找来一些简单的实现...

    C#窗体全屏功能

    C#应用程序中如何实现全屏幕显示功能?
     效果就像windows自带的屏幕保护程序和众多的游戏那样,无论是否设置了“将任务栏保持在其他窗口的前端”都不显示任务栏

    实现方式一

    在网上找来一些简单的实现方式:

    this.FormBorderStyle = FormBorderStyle.None;     //设置窗体为无边框样式
    this.WindowState = FormWindowState.Maximized;    //最大化窗体 

    或者

    this.TopMost= True;     //设置窗体为最前端显示
    this.WindowState = FormWindowState.Maximized;    //最大化窗体 

    把以上两句代码直接放到Form1_Load的方法中,就可以了,比较简单,我就不贴代码了。

    参考出处:http://blog.csdn.net/friendan/article/details/7350570

    ============================================================

    实现方式二

    调用系统的API函数,如user32.dll中的FindWindow和ShowWindow函数,具体代码如下:

            [DllImport("user32.dll", EntryPoint = "ShowWindow")]
            public static extern Int32 ShowWindow(Int32 hwnd, Int32 nCmdShow);
    
            [DllImport("user32.dll", EntryPoint = "FindWindow")]
            private static extern Int32 FindWindow(string lpClassName, string lpWindowName);

    代码如下:

    复制代码
    using System;
    using System.Windows.Forms;
    
    using System.Drawing;
    using System.Runtime.InteropServices;
    
    
    namespace FullScr
    {
        public partial class Form1 : Form
        {
    
            Boolean m_IsFullScreen = false;//标记是否全屏
    
    
            public Form1()
            {
                InitializeComponent();
            }
    
    
            private void Form1_Load(object sender, EventArgs e)
            {
            }
    
            /// <summary>
            ///  全屏按钮的Click事件
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void button1_Click(object sender, EventArgs e)
            {
                m_IsFullScreen = !m_IsFullScreen;//点一次全屏,再点还原。  
                this.SuspendLayout();
                if (m_IsFullScreen)//全屏 ,按特定的顺序执行
                {
                    SetFormFullScreen(m_IsFullScreen);
                    this.FormBorderStyle = FormBorderStyle.None;
                    this.WindowState = FormWindowState.Maximized;
                    this.Activate();//
                }
                else//还原,按特定的顺序执行——窗体状态,窗体边框,设置任务栏和工作区域
                {
                    this.WindowState = FormWindowState.Normal;
                    this.FormBorderStyle = FormBorderStyle.Sizable;
                    SetFormFullScreen(m_IsFullScreen);
                    this.Activate();
                }
                this.ResumeLayout(false);
            }
    
            /// <summary>  
            /// 设置全屏或这取消全屏  
            /// </summary>  
            /// <param name="fullscreen">true:全屏 false:恢复</param>  
            /// <param name="rectOld">设置的时候,此参数返回原始尺寸,恢复时用此参数设置恢复</param>  
            /// <returns>设置结果</returns>  
            public Boolean SetFormFullScreen(Boolean fullscreen)//, ref Rectangle rectOld
            {
                Rectangle rectOld = Rectangle.Empty;
                Int32 hwnd = 0;
                hwnd = FindWindow("Shell_TrayWnd", null);//获取任务栏的句柄
    
                if (hwnd == 0) return false;
    
                if (fullscreen)//全屏
                {
                    ShowWindow(hwnd, SW_HIDE);//隐藏任务栏
    
                    SystemParametersInfo(SPI_GETWORKAREA, 0, ref rectOld, SPIF_UPDATEINIFILE);//get屏幕范围
                    Rectangle rectFull = Screen.PrimaryScreen.Bounds;//全屏范围
                    SystemParametersInfo(SPI_SETWORKAREA, 0, ref rectFull, SPIF_UPDATEINIFILE);//窗体全屏幕显示
                }
                else//还原 
                {
                    ShowWindow(hwnd, SW_SHOW);//显示任务栏
                    SystemParametersInfo(SPI_SETWORKAREA, 0, ref rectOld, SPIF_UPDATEINIFILE);//窗体还原
                }
                return true;
            }
    
            #region user32.dll
    
            public const Int32 SPIF_UPDATEINIFILE = 0x1;
            public const Int32 SPI_SETWORKAREA = 47;
            public const Int32 SPI_GETWORKAREA = 48;
            public const Int32 SW_SHOW = 5;
            public const Int32 SW_HIDE = 0;
    
            [DllImport("user32.dll", EntryPoint = "ShowWindow")]
            public static extern Int32 ShowWindow(Int32 hwnd, Int32 nCmdShow);
    
            [DllImport("user32.dll", EntryPoint = "FindWindow")]
            private static extern Int32 FindWindow(string lpClassName, string lpWindowName);
    
            [DllImport("user32.dll", EntryPoint = "SystemParametersInfo")]
            private static extern Int32 SystemParametersInfo(Int32 uAction, Int32 uParam, ref Rectangle lpvParam, Int32 fuWinIni);
    
            #endregion
    
        }
    }
    复制代码

    实现方式三

    窗体最大化,不占用任务栏,具体实现如下:

    this.MaximizedBounds = Screen.PrimaryScreen.WorkingArea; //设置最大化的大小为工作区域
    this.WindowState = FormWindowState.Maximized;


    参考出处:http://www.cnblogs.com/ArcScofield/archive/2013/01/02/Form_Fullscreen.html
    展开全文
  • C#窗体简单贪吃蛇

    2013-12-07 11:59:17
    简单的Form窗体贪吃蛇游戏,容易看懂,容易学习
  • c#语言做的简单的扫雷小游戏,内容简单,代码简易,逻辑清晰,可供c#初学者制作参考,相信对初学者有所帮助。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,671
精华内容 2,268
关键字:

c#窗体游戏

c# 订阅