简单五子棋，没有电脑AI

　　刚学了C#委托，做了个五子棋练习，把前台绘制和后台逻辑分开，前台绘制方法用委托传给后台逻辑。

界面好简单。。。

先看类图

控制类控制整个游戏的逻辑，包括调用棋盘类的属性初始化棋盘、初始化两个棋手、轮流落子。棋盘里有一个二维数组保存整个棋盘的落子情况，棋手里也有一个二维数组保存自己的落子情况。方向类是为了方便判断输赢的。

下面是代码：注释很详细就不说明了：

主要控制类：

using System;
using System.Collections.Generic;
using System.Drawing;
using 五子棋.Properties;

namespace 五子棋.Control
{
    class Controler
    {
        #region 字段
        ///// <summary>
        ///// 画家对象
        ///// </summary>
        //Graphics g;
        /// <summary>
        /// 棋盘对象
        /// </summary>
        QiPan qipan;
        /// <summary>
        /// 棋手列表
        /// </summary>
        List<QiShou> qishou;
        /// <summary>
        /// 游戏是否结束
        /// </summary>
        bool Gameover = false;
        /// <summary>
        /// 绘制直线委托
        /// </summary>
        Action<Point, Point> actionDrawLine;
        /// <summary>
        /// 绘制棋子图像委托
        /// </summary>
        Action<Image, int, int, float> actionDrawimage;
        /// <summary>
        /// 取得胜利事件，返回胜利选手的名称
        /// </summary>
        Action<string> actionWin;
        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="actionDrawLine">绘制直线委托</param>
        /// <param name="actionDrawimage">绘制棋子图像委托</param>
        public Controler(Action< Point, Point> actionDrawLine, Action<Image, int, int, float> actionDrawimage,Action<string> actionWin)
        {
            //开始游戏
            this.actionDrawLine = actionDrawLine;
            this.actionDrawimage = actionDrawimage;
            this.actionWin = actionWin;
            StartGame();
        }
        #endregion

        #region 方法

        /// <summary>
        /// 棋手轮流下棋
        /// </summary>
        /// <param name="x">棋子X坐标</param>
        /// <param name="y">棋子Y坐标</param>
        public void LuoZi(int x, int y)
        {
            if (Gameover)
            {
                return;
            }
            //把不在棋盘交点上的坐标换算到最接近的棋盘交点上

            //x = (int)Math.Round((double)(x - qipan.start.X) / qipan.Grid)
            //    * qipan.Grid + qipan.start.X;
            //y = (int)Math.Round((double)(y - qipan.start.Y) / qipan.Grid)
            //    * qipan.Grid + qipan.start.Y;
            //换算到棋盘第几条线
            int qipanX = (int)Math.Round((double)(x - qipan.start.X) / qipan.Grid);
            int qipanY = (int)Math.Round((double)(y - qipan.start.Y) / qipan.Grid);
            if (qipan[qipanX, qipanY] == 0)
            {
                for (int i = 0; i < qishou.Count; i++)
                {
                    if (qishou[i].IsZouqi)
                    {
                        qipan[qipanX, qipanY] = 1;
                        qishou[i].LuoZi(qipanX, qipanY);
                        //换算到棋盘控件坐标并绘制棋子
                        qishou[i].Render(qipanX * qipan.Grid + qipan.start.X,
                            qipanY * qipan.Grid + qipan.start.Y, actionDrawimage);

                        //判断当前玩家是否获胜，获胜则游戏结束
                        Gameover = IsWin(qishou[i], new Point(qipanX, qipanY));
                        if (Gameover)
                        {
                            //if (actionWin!=null)
                            //{
                            //    actionWin.Invoke(qishou[i].PlayerName);
                            //}
                            actionWin?.Invoke(qishou[i].PlayerName);
                        }

                        //走棋后设置棋手不可走棋
                        //qishou[i].LuoZi(x, y, g);
                    }
                    qishou[i].IsZouqi = !qishou[i].IsZouqi;
                }
            }
        }
        /// <summary>
        /// 刷新界面
        /// </summary>
        public void Render()
        {
            qipan.Render(actionDrawLine);
            for (int i = 0; i < qishou.Count; i++)
            {
                qishou[i].Render(qipan.start, qipan.Grid, actionDrawimage);
            }
        }
        /// <summary>
        /// 判断是否获胜
        /// </summary>
        /// <param name="qishou">棋手</param>
        /// <param name="p">当前棋子坐标</param>
        /// <returns></returns>
        public bool IsWin(QiShou qishou, Point p)
        {

            //如果点在连续直线上就累加，当sum=5时，表示连续5个棋子在一条直线上
            int sum = 1;
            for (int i = 0; i < 8; i++)
            {
                Console.WriteLine(i);
                //下一个要检查的点
                Point nextP = p;
                Direction dr = (Direction)i;
                if (i % 2 == 0)
                {
                    sum = 1;
                }
                for (int j = 0; j < 5; j++)
                {
                    //根据当前方向判断设置下一个点
                    #region switch
                    switch (dr)
                    {
                        case Direction.Top:
                            nextP.X = nextP.X;
                            nextP.Y = nextP.Y - 1;
                            break;
                        case Direction.RightTop:
                            nextP.X = nextP.X + 1;
                            nextP.Y = nextP.Y - 1;
                            break;
                        case Direction.Rigth:
                            nextP.X = nextP.X + 1;
                            nextP.Y = nextP.Y;
                            break;
                        case Direction.RigthBotton:
                            nextP.X = nextP.X + 1;
                            nextP.Y = nextP.Y + 1;
                            break;
                        case Direction.Botton:
                            nextP.X = nextP.X;
                            nextP.Y = nextP.Y + 1;
                            break;
                        case Direction.LeftBotton:
                            nextP.X = nextP.X - 1;
                            nextP.Y = nextP.Y + 1;
                            break;
                        case Direction.Left:
                            nextP.X = nextP.X - 1;
                            nextP.Y = nextP.Y;
                            break;
                        case Direction.LeftTop:
                            nextP.X = nextP.X - 1;
                            nextP.Y = nextP.Y - 1;
                            break;
                        default:
                            break;
                    }
                    #endregion

                    if (nextP.X >= 0 && nextP.X < qishou.ZouQiQiPan.GetLength(0)
                        && nextP.Y >= 0 && nextP.Y < qishou.ZouQiQiPan.GetLength(1))
                    {
                        if (qishou.ZouQiQiPan[nextP.X, nextP.Y] == 0)
                        {
                            break;
                        }
                        else
                        {
                            sum += qishou.ZouQiQiPan[nextP.X, nextP.Y];
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                if (sum == 5)
                {
                    return true;
                }

            }

            return false;
        }
        /// <summary>
        /// 开始游戏
        /// </summary>
        public void StartGame()
        {
            Gameover = false;
            //初始化棋盘
            qipan = new QiPan();
            //初始化两种棋手：白棋和黑棋
            qishou = new List<QiShou>()
            {
                new QiShou(Resources.白棋,0.08f,new byte[qipan.Heigth/qipan.Grid+1,qipan.Width/qipan.Grid+1]) {IsZouqi=true,PlayerName="Bai" },

                new QiShou(Resources.黑棋,0.08f,new byte[qipan.Heigth/qipan.Grid+1,qipan.Width/qipan.Grid+1]) { IsZouqi=false,PlayerName="Hei" }
            };
            Render();
        }
        #endregion

    }
}

棋手类：

using System;
using System.Drawing;

namespace 五子棋.Control
{
    class QiShou
    {
        #region 字段
        /// <summary>
        /// 棋子图像
        /// </summary> 
        /// /// <summary>
        /// 走棋棋盘
        /// </summary>
        byte[,] zouqiqipan;
        #endregion
        #region 属性
        public string PlayerName { get; set; }
        public Image ImagePlayer { get; set; }
        /// <summary>
        /// 棋子图像缩放比例
        /// </summary>
        public float ImageScale { get; set; }

        /// <summary>
        /// 走棋棋盘
        /// </summary>
        public byte[,] ZouQiQiPan
        {
            get
            {
                return zouqiqipan;
            }
            set
            {
                zouqiqipan = value;
            }
        }
        /// <summary>
        /// 是否可以走棋
        /// </summary>
        public bool IsZouqi { get; set; } 
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="image">棋子图像</param>
        /// <param name="imagescale">棋子缩放比例</param>
        /// /// <param name="zouqiqipan">走棋棋盘大小</param>
        public QiShou(Image image, float imagescale, byte[,] zouqiqipan)
        {
            this.zouqiqipan = zouqiqipan;
            ImagePlayer = image;
            ImageScale = imagescale;
            Init();
        }
        /// <summary>
        /// 初始化棋手
        /// </summary>
        private void Init()
        {
            for (int i = 0; i < zouqiqipan.GetLength(0); i++)
            {
                for (int j = 0; j < zouqiqipan.GetLength(1); j++)
                {
                    zouqiqipan[i, j] = 0;
                }
            }
        }

        /// <summary>
        /// 下棋落字
        /// </summary>
        /// <param name="x">棋盘X网格</param>
        /// <param name="y">棋盘Y网格</param>
        public void LuoZi(int x, int y)
        {
            ZouQiQiPan[x, y] = 1;
        }
        #region 绘制棋子
        /// <summary>
        /// 绘制所有棋子
        /// </summary>
        /// <param name="start"></param>
        /// <param name="grid"></param>
        public void Render(Point start, int grid,Action<Image, int,int,float> actionDrawImage)
        {
            for (int i = 0; i < ZouQiQiPan.GetLength(0); i++)
            {
                for (int j = 0; j < ZouQiQiPan.GetLength(1); j++)
                {
                    if (zouqiqipan[i, j] == 1)
                    {
                        Render(i * grid + start.X, i * grid + start.Y,actionDrawImage);

                    }
                }
            }
        }
        public void Render(int x,int y, Action<Image, int, int, float> actionDrawImage)
        {
            actionDrawImage?.Invoke(ImagePlayer, x, y, ImageScale);
        }
        ///// <summary>
        ///// 绘制棋子
        ///// </summary>
        ///// <param name="x">棋盘X网格坐标</param>
        ///// <param name="y">棋盘Y网格坐标</param>
        ///// <param name="g">画家对象</param>
        //public void Render(int x, int y)
        //{
        //    //actionDrawimage(x, y, ImagePlayer, ImageScale);


        //    //绘制棋子，绘制的坐标应该换算到中心
        //    g.DrawImage(ImagePlayer, x - ImagePlayer.Width * ImageScale / 2, y - ImagePlayer.Height * ImageScale / 2,
        //        ImagePlayer.Width * ImageScale, ImagePlayer.Height * ImageScale);
        //}
        #endregion
        

    }
    
}

棋盘类：

using System;
using System.Drawing;

namespace 五子棋.Control
{
    class QiPan
    {

        /// <summary>
        /// 棋盘绘制起点坐标
        /// </summary>
        public readonly Point start;
        /// <summary>
        /// X缩放
        /// </summary>
        public int ScaleX { get; set; }
        /// <summary>
        /// Y缩放
        /// </summary>
        public int ScaleY { get; set; }
        /// <summary>
        /// 棋盘宽度
        /// </summary>
        public int Width { get; set; }
        /// <summary>
        /// 棋盘高度
        /// </summary>
        public int Heigth { get; set; }
        /// <summary>
        /// 网格大小
        /// </summary>
        public int Grid { get; set; }
        /// <summary>
        /// 棋盘棋子
        /// </summary>
        private byte[,] qipanQiZi;
        public byte this[int x, int y]
        {
            get
            {
                if (x < qipanQiZi.GetLength(0) && y < qipanQiZi.GetLength(1))
                {
                    return qipanQiZi[x, y];
                }
                else
                {
                    return 0;
                }
            }
            set
            {
                if (x < qipanQiZi.GetLength(0) && y < qipanQiZi.GetLength(1))
                {
                    qipanQiZi[x, y] = value;
                }
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="width">棋盘宽度</param>
        /// <param name="height">棋盘高度</param>
        /// <param name="grid">棋盘网格大小</param>
        public QiPan(Point start, int width, int height, int grid)
        {
            this.start = start;
            Width = width;
            Heigth = height;
            Grid = grid;
            Init();

        }

        private void Init()
        {
            qipanQiZi = new byte[Width / Grid + 1, Heigth / Grid + 1];
            for (int i = 0; i < qipanQiZi.GetLength(0); i++)
            {
                for (int j = 0; j < qipanQiZi.GetLength(1); j++)
                {
                    qipanQiZi[i, j] = 0;
                }
            }
        }

        /// <summary>
        /// 构造函数
        /// 默认棋盘大小为400*400，方格大小为40
        /// </summary>
        public QiPan() : this(new Point(50, 50), 400, 400, 40)
        {
        }
        #region Graphics绘制棋盘


        /// <summary>
        /// 绘制棋盘
        /// </summary>
        /// <param name="g"></param>
        //public void Render(Graphics g)
        //{
        //    for (int i = 0; i <= Width / Grid; i++)
        //    {
        //        g.DrawLine(Pens.Black, start.X + (Grid * i), start.Y, start.X + (Grid * i), start.Y + Heigth);

        //    }
        //    for (int i = 0; i <= Heigth / Grid; i++)
        //    {
        //        g.DrawLine(Pens.Black, start.X, start.Y + (Grid * i), start.X + Width, start.Y + (Grid * i));
        //    }
        //}
        #endregion
        public void Render(Action< Point, Point> actionDrawLine)
        {
            int row = Heigth / Grid + 1;
            int cel = Width / Grid + 1;
            for (int i = 0; i < row; i++)
            {
                actionDrawLine?.Invoke( new Point(start.X, start.Y + Grid * i), new Point(start.X + Width, start.Y + Grid * i));
            }
            for (int i = 0; i < cel; i++)
            {
                actionDrawLine?.Invoke( new Point(start.X + Grid * i, start.Y), new Point(start.X + Grid * i, start.Y + Heigth));
            }
        }
    }
}