精华内容
下载资源
问答
  • 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

    展开全文
  • Python如何编写窗体程序python和很多软件的用法其实差不多,只是代码更为简洁,代码量没这么多。窗体的写法也和java类似,现在举个例子:编写一个点名器,有一个按钮当被点击时,会随机产生一个数字,该数字显示在一...

    Python如何编写窗体程序

    python和很多软件的用法其实差不多,只是代码更为简洁,代码量没这么多。

    窗体的写法也和java类似,现在举个例子:编写一个点名器,有一个按钮当被点击时,会随机产生一个数字,该数字显示在一个标签上。import tkinter as tk

    import random

    bot = False

    def func():

    global bot

    if bot==False:

    bot=True

    var.set("有请第%d组上台" % random.randint(1,14))

    else:

    bot=False

    var.set('---------')

    window = tk.Tk() #创建一个窗口对象

    window.title("随机点名器1.0")#设置窗口标题

    window.geometry('300x300')#设置窗口大小

    var=tk.StringVar()#创建一个文字对象

    l = tk.Label(textvar=var,font=('Arial',25),bg='red',width=40,height=6)#创建标签对象 设置文字内容,背景颜色,高和宽

    l.pack()#放置按钮

    but = tk.Button(text="点我一下试试",width=20,height=4,command=func)#创建按钮对象设置属性 command用来连接功能函数(方法)

    but.pack()#放置按钮

    window.mainloop()#运行

    更多技术请关注云海天Python教程。

    展开全文
  • Java swing窗体程序

    2021-10-09 15:47:20
    早期的AWT(抽象窗口工具包)组件开发的图形用户界面,要依赖本地系统,当把AWT组件开发的应用程序移植到其他平台的系统上运行时,不能保证其外观风格,因此AWT是依赖于本地系统平台的。而使用Swing开发的Java应用...

    Swing是GUI(图形用户界面)开发工具包,包括容器、组件和布局等。

    早期的AWT(抽象窗口工具包)组件开发的图形用户界面,要依赖本地系统,当把AWT组件开发的应用程序移植到其他平台的系统上运行时,不能保证其外观风格,因此AWT是依赖于本地系统平台的。而使用Swing开发的Java应用程序,其界面是不受本地系统平台限制的,也就是说Swing开发的Java应用程序移植到其他系统平台上时,其界面外观是不会改变的。但要注意的是,虽然Swing提供的组件可以方便开发Java应用程序,但是Swing并不能取代AWT,在开发Swing程序时通常要借助与AWT的一些对象来共同完成应用程序的设计。

    一、常用窗体
      Swing窗体是Swing的一个组件,同时也是创建图形化用户界面的容器,可以将其它组件放置在窗体容器中。

    1. JFrame框架窗体
      JFrame窗体是一个容器,在Swing开发中我们经常要用到,它是Swing程序中各个组件的载体。语法格式如下:

    JFrame jf = new JFrame(title);
    

    当然,在开发中更常用的方式是通过继承java.swing.JFrame类创建一个窗体,可通过this关键字调用其方法。

    而在JFrame对象创建完成后,需要调用getContentPane()方法将窗体转换为容器,然后在容器中添加组件或设置布局管理器,通常这个容器用来包含和显示组件。如果需要将组件添加至容器,可以使用来自Container类的add()方法进行设置。至于JPanel容器会在后面提到。

    下面举一个JFrame窗体的例子。

    import javax.swing.JFrame;
    import javax.swing.WindowConstants;
    
    public class JFrameDemo {
    
        public void CreateJFrame() {
            JFrame jf = new JFrame("这是一个JFrame窗体");        // 实例化一个JFrame对象
            jf.setVisible(true);        // 设置窗体可视
            jf.setSize(500, 350);        // 设置窗体大小
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);        // 设置窗体关闭方式
        }
    
        public static void main(String[] args) {
            new JFrameDemo().CreateJFrame();        // 调用CreateJFrame()方法
        }
    
    }
    

    结果:在这里插入图片描述
    这就是一个500*350的窗体,用的是setSize()方法;标题为“这是一个JFrame窗体”,在实例化对象时就可以定义;窗体关闭方式见窗体右上角为“EXIT_ON_CLOSE”;窗体可视setVisible()方法中的参数为“false”或不写setVisible()方法时,此窗体不可见。

    常用的窗体关闭方式有四种,分别为“DO_NOTHING_ON_CLOSE”、“DISPOSE_ON_CLOSE”、“HIDE_ON_CLOSE”、“EXIT_ON_CLOSE”。第一种表示什么也不做就将窗体关闭;第二种表示任何注册监听程序对象后会自动隐藏并释放窗体;第三种表示隐藏窗口的默认窗口关闭;第四种表示退出应用程序默认窗口关闭。
      下面再举一个用继承JFrame的方式编写的代码,并加入Container容器及JLabel标签

    import java.awt.Color;
    import java.awt.Container;
    
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.SwingConstants;
    import javax.swing.WindowConstants;
    
    public class JFrameDemo2 extends JFrame{
    
        public void init() {
            this.setVisible(true);        // 可视化
            this.setSize(500, 350);        // 大小
            this.setTitle("博客园");        // 标题
            this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);        // 关闭方式
    
            JLabel jl = new JLabel("http://www.cnblogs.com/adamjwh/");        // 创建一个JLabel标签
            jl.setHorizontalAlignment(SwingConstants.CENTER);        // 使标签文字居中
    
            Container container = this.getContentPane();        // 获取一个容器
            container.add(jl);        // 将标签添加至容器
            container.setBackground(Color.YELLOW);        // 设置容器背景颜色
        }
    
        public static void main(String[] args) {
            new JFrameDemo2().init();
        }
    
    }
    

    结果:
    在这里插入图片描述
    这里继承了JFrame类,所以方法中实现时用this关键字即可(或直接实现,不加this)。1215行为创建JFrame框体;17、18行为JLabel标签,用与添加一个标签;2022行为Container容器,用getContentPane()方法为JFrame窗体获取容器,并用add()方法将JLabel标签添加到容器上。

    2. JDialog窗体
      JDialog窗体是Swing组件中的对话框,继承了AWT组件中的java.awt.Dialog类。功能是从一个窗体中弹出另一个窗体。

    下面来看一个实例:

    import java.awt.Container;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.JButton;
    import javax.swing.JDialog;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.WindowConstants;
    
    public class JDialogDemo extends JDialog {        // 继承JDialog类
    
        public JDialogDemo() {
            super(new MyJFrame(), "这是一个JDialog窗体", true); // 实例化一个JDialog类对象,指定其父窗体、窗口标题和类型
            Container container = this.getContentPane();
            container.add(new JLabel("http://www.cnblogs.com/adamjwh/"));
            this.setSize(500, 350);
        }
    
    
        public static void main(String[] args) {
            new JDialogDemo();
        }
    
    }
    
    // 下面这部分内容包含监听器,可自行查阅资料
    class MyJFrame extends JFrame {
        public MyJFrame() {
            this.setVisible(true);
            this.setSize(700, 500);
            this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    
            Container container = this.getContentPane();
            container.setLayout(null);
    
            JButton jb = new JButton("点击弹出对话框");        // 创建按钮
            jb.setBounds(30, 30, 200, 50);        // 按钮位置及大小
            jb.addActionListener(new ActionListener() {        // 监听器,用于监听点击事件
                @Override
                public void actionPerformed(ActionEvent e) {
                    new JDialogDemo().setVisible(true);
                }
            });
            container.add(jb);
        }
    }
    

    结果:在这里插入图片描述
    当我们点击按钮时,触发点击事件,这时执行第42行的语句,创建一个JDialog的实例化对象,弹出一个窗口。这里出现了许多我们之前学过的知识,比如super关键字,在之前提到过,这里相当于使用了JDialog(Frame f, String title, boolean model)形式的构造方法;监听器的实现就是一个匿名内部类。
    二、标签组件
      在Swing中显示文本或提示信息的方法是使用标签,它支持文本字符串和图标。上面我们提到的JLabel就是这里的内容。

    1. 标签
      标签由JLabel类定义,可以显示一行只读文本、一个图像或带图像的文本。

    JLabel类提供了许多构造方法,可查看API选择需要的使用,如显示只有文本的标签、只有图标的标签或包含文本与图标的标签等。因为上面已经出现过了,这里就不再举例了。常用语法格式如下,创建的是一个不带图标和文本的JLabel对象:

    JLabel jl = new JLabel();
    
    

    2. 图标
      Swing中的图标可以放置在按钮、标签等组件上,用于描述组件的用途。图标可以用Java支持的图片文件类型进行创建,也可以使用java.awt.Graphics类提供的功能方法来创建。

    在Swing中通过Icon接口来创建图标,可以在创建时给定图标的大小、颜色等特性。注意,Icon是接口,在使用Icon接口的时候,必须实现Icon接口的三个方法:

    public int getIconHeight()
    public int getIconWidth()
    public void paintIcon(Component arg0, Graphics arg1, int arg2, int arg3)
    

    下面看一个用Icon接口创建图标的实例:

    import java.awt.Component;
    import java.awt.Container;
    import java.awt.Graphics;
    
    import javax.swing.Icon;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.SwingConstants;
    import javax.swing.WindowConstants;
    
    public class IconDemo extends JFrame implements Icon {
    
        private int width;        // 声明图标的宽
        private int height;        // 声明图标的长
    
        public IconDemo() {}        // 定义无参构造方法
    
        public IconDemo(int width, int height) {        // 定义有参构造方法
            this.width = width;
            this.height = height;
        }
    
        @Override
        public int getIconHeight() {        // 实现getIconHeight()方法
            return this.height;
        }
    
        @Override
        public int getIconWidth() {            // 实现getIconWidth()方法
            return this.width;
        }
    
        @Override
        public void paintIcon(Component arg0, Graphics arg1, int arg2, int arg3) {        // 实现paintIcon()方法
            arg1.fillOval(arg2, arg3, width, height);        // 绘制一个圆形
        }
    
        public void init() {    // 定义一个方法用于实现界面
            IconDemo iconDemo = new IconDemo(15, 15);        // 定义图标的长和宽
            JLabel jb = new JLabel("icon测试", iconDemo, SwingConstants.CENTER);    // 设置标签上的文字在标签正中间
    
            Container container = getContentPane();
            container.add(jb);
    
            this.setVisible(true);
            this.setSize(500, 350);
            this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        }
    
        public static void main(String[] args) {
            new IconDemo().init();
        }
    
    }
    

    在这里插入图片描述

    展开全文
  • Java窗体程序实例

    2021-03-06 03:54:11
    //使点击红X可以退出程序label=newJLabel();//用于显示照片add(label); chooser=newJFileChooser();//文件浏览器chooser.setCurrentDirectory(newFile(".")); JMenuBar menuBar=newJMenuBar();//菜单栏setJMenuBar...

    importjava.awt.event.ActionEvent;importjava.awt.event.ActionListener;importjava.io.File;importjavax.swing.ImageIcon;importjavax.swing.JFileChooser;importjavax.swing.JFrame;importjavax.swing.JLabel;importjavax.swing.JMenu;importjavax.swing.JMenuBar;importjavax.swing.JMenuItem;publicclassImageViewer {publicstaticvoidmain(String[] args) {

    JFrame frame=newImageViewerFrame();

    frame.setVisible(true);

    }

    }classImageViewerFrameextendsJFrame {privateJLabel label;privateJFileChooser chooser;privatestaticfinallongserialVersionUID=1L;//序列化版本publicImageViewerFrame() {

    setTitle("ImageViewer");

    setSize(300,400);

    setLocationRelativeTo(null);//初始在屏幕中央setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//使点击红X可以退出程序label=newJLabel();//用于显示照片add(label);

    chooser=newJFileChooser();//文件浏览器chooser.setCurrentDirectory(newFile("."));

    JMenuBar menuBar=newJMenuBar();//菜单栏setJMenuBar(menuBar);

    JMenu menu=newJMenu("File");

    menuBar.add(menu);

    JMenuItem openItem=newJMenuItem("Open");

    menu.add(openItem);

    openItem.addActionListener(newActionListener() {//显示浏览文件对话框publicvoidactionPerformed(ActionEvent event) {intresult=chooser.showOpenDialog(null);if(result==JFileChooser.APPROVE_OPTION) {

    String filename=chooser.getSelectedFile()

    .getPath();

    label.setIcon(newImageIcon(filename));

    }

    }

    });

    JMenuItem exitItem=newJMenuItem("Exit");

    menu.add(exitItem);

    exitItem.addActionListener(newActionListener() {//菜单中的退出按钮publicvoidactionPerformed(ActionEvent event) {

    System.exit(0);

    }

    });

    }

    }

    展开全文
  • python通过tkinter制作窗体程序Tkinter Tkinter Tkinter是python用来进行窗体设计的小模块。我也不是很会用,就在这做一个小笔记吧!???? 我是做了一个验证加法是否正确的简单窗体程序 首先生成两个随机数,然后在...
  • 布局(Layout),是Swing窗体程序设计の至关重要的东西。 譬如说,你去看一个网站,你会怎么判断这个网站使人舒不舒服?当然是看这个网站排兵布阵得好不好看喽,就像csdn写博客的地方,最上面是“发布文章”的...
  • 62616964757a686964616fe59b9ee7ad94313333613262662、创建窗体;3、消息循环;4、编写窗口消息处理函数。代码:#include#includeLRESULTCALLBACKWindowProc(HWNDhwnd,UINTmsg,WPARAMwParam,LPARAMlParam);intWINAPI...
  • 1.点击File-->New-->Other 2.选择WindowsBuilder-->Swing Designer-->JFrame
  • 现在不少网友不知道eclipse开发程序建立一个窗的操作,接下来这篇文章就详细介绍eclipse开发程序建立一个窗方法。希望可以帮助到大家!eclipse开发程序建立一个窗口的操作教程1、打开eclipse;2、建立一个java工程;3、...
  • 打开文件夹: 例如:C:\Windows System.Diagnostics.Process.Start("explorer", "/n, C:\\Windows");...打开应用程序: 例如:打开控制面板 System.Diagnostics.Process.Start("C:\\Windows\\system32\\contro
  • 问题详情vs2008 c#开发windows窗体程序,怎么连接数据库?我的oracle服务器为WebServer数据库为MIS,用户名为MIS,密码为MIS;我在vs2008 c#开发windows窗体程序,怎么连接我的数据库呢?比如我用一个DataGrideView...
  • 接下来上代码和窗体界面 窗体界面 右边有5个按钮,分别为 开始游戏、重新开始、游戏规则、退出、确认 数字和删除键也都是按钮、backcolor设为白色 拖三个 Label 控件,用来提示次数,几A几B,和输入的数字 我用的是...
  • C#在高分屏上让窗体程序忽略系统的显示缩放 在Program.cs添加如下代码: [STAThread] static void Main() { if (Environment.OSVersion.Version.Major >= 6) SetProcessDPIAware(); Application....
  • 目录 一.使用RichTextBox输出实时信息到窗体 二.保存输出记录到电脑本地文件夹中 三.在Winform界面查询RichTextBox控件输出的文本内容
  • 1.在这里主要以一个人员薪酬表为例子,做简单的增删改等操作,以及快速生成工资条,窗口示例如下2.数据表信息如下3.生成的工资表如下4.详细代码如下'添加员工信息Private Sub CommandButton1_Click()Dim iDim w1Set ...
  • Must qualify the allocation with an enclosing 解决方案一: 主程序是public static class main 在Java中,类中的静态方法不能直接调用动态方法。 静态main方法中只能调用静态类 在调用类前加static可解决 解决...
  • 第一个Python窗体程序

    2021-03-06 19:55:44
    问题: 1: app = QApplication(sys.argv)//必须传入参数 初始化窗口系统并且使用在argv中的argc个命令行参数构造一个应用程序对象。参考http://www.kuqin.com/qtdocument/qapplication.html#QApplication 2:PyQt4...
  • 编写一个窗体程序,输出能同时被2,3,5整除,且不是100的倍数的数字,要求如下: 1)用户可以指定数字区间。 2)用户可以指定输出一行数字的个数,且数字之间间隔一个Tab宽度。 3)程序需对用户输入进行检验是否是...
  • 在Winform程序开发中,当我们需要固定某个时间来执行某个方法函数来达到一个功能效果,我们可以这样做。 首先,创建一个 项目 打开From窗体 选中窗体,双击或者按F7 在构造函数里面写 //定时器 ...
  • 配置文件内容: 关于这个配置文件详细使用,请移步: https://blog.csdn.net/weixin_39237340/article/details/92561824 建立一个窗体,托入一个button按钮,双击进入Click事件 上代码 using System; using System....
  • Windows窗体程序(权限问题,不建议把项目放C盘) 3.点击左侧栏的工具箱,鼠标Button、Label、textBox拖入到窗体界面中,分别放置到合适的位置。 4.点击各个组件,在右下角可以设置外观等属性(文字大小、颜色等...
  • 【问题】C#程序,希望将窗体程序在系统托盘上显示。【解决过程】1.参考:C#系统托盘,但是没找到notifyIconMinimize,所以还是没解决问题。(1)先在窗体属性中,关闭了ShowInTaskbar:(2)从工具箱中,拖动一个...
  • 在java窗体程序中添加图片的方法

    千次阅读 2021-02-13 02:01:12
    在java窗体程序中添加图片的方法发布时间:2020-06-16 11:24:13来源:亿速云阅读:148作者:Leah这篇文章主要为大家详细介绍了在java窗体程序中添加图片的方法,图文详解容易学习,配合代码阅读理解效果更佳,非常...
  • 在C#的Winform窗体程序开发过程中,我们可以通过设置Winform窗体的BackgroundImage属性来达到设置Winform窗体程序的背景图,如果图片的大小与窗体程序的大小不一样,可能会导致背景图显示不全,此时就需要设置背景图...
  • Qt提供了可视化界面设计工具Qt Designer,可视化设计UI窗体可大大提高GUI应用程序开发的工作效率。本例演示如何用Qt Designer可视化设计UI窗体,然后转换为Python程序,再构建GUI程序。主要工作步骤如下: 在Qt ...
  • 给你一个javascript的程序,文件名保存为1.html就可以网页开屏 var x = 10;var dx = 5;var y = window.screen.availHeight;var newWin = window.open("", "myWin", "menubar=0,toolbar=0");newWin.document.write("I...
  • 窗体应用程序设计

    2021-04-24 21:23:10
    实验四 窗体应用程序设计 实验名称:C#窗体应用程序设计<一> (1)在主窗口上放置一ListBox和两个Button,Button1和Button2;新建Window窗体Form2,在Form2上放置一button;要求主窗体居中显示。 (2) 点击...
  • 实训要求:编写一个窗体程序,能够对文本区中的文字设置字体和大小。代码:import java.awt.*;import java.awt.event.*;import javax.swing.*;public class FontChange extends JFrame implements ItemListener {...
  • Qt 早期是一个跨平台C++ 图形用户界面应用程序开发框架,内部封装了大量的跨平台库,可以在 linux、windows、android、ios 等平台运行其编写的程序,并且还提供了一个强大的 IDE 工具 名为 Qt Creator。Qt 让我们对...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 220,648
精华内容 88,259
关键字:

窗体程序