五字棋

Question

我想编写一个五字棋游戏，征集思路和源代码， 游戏设 无禁手规则，只需有五点成线即可。

Answer 1

哟西，坐等高手出现。[align=center]**********************************************
欢迎使用 CSDN 小秘书
http://blog.csdn.net/whowhen21
**********************************************[/align]

Answer 2

你可以加我QQ343229661，我可以发java源码给你，我妹妹给我的，让我帮她注释，她看不懂，Java和C#差不多，稍微修改下

Answer 3

发到这里吧：[email protected] 

Answer 4

using System;
using System.Collections.Generic;
//using System.Linq;
using System.Text;
using System.Collections;
using System.Drawing;namespace FivePiecesChess
{
    class PieceRoad
    {
        /// <summary>
        /// 私有字段，棋谱，用来记录每一步棋
        /// </summary>
        private List<PieceStep> road = new List<PieceStep>();
        /// <summary>
        /// 私有字段，棋盘，用来记录每一位置的棋子，1为黑子，-1为白字，0为未落子
        /// </summary>
        private int[,] pieceArray = new int[15,15];
        /// <summary>
        /// 私有字段，下一步棋子的颜色
        /// </summary>
        private EnumPieceColor nextColor;
        /// <summary>
        /// 私有字段，总共下子数目
        /// </summary>
        private int stepNum;
        /// <summary>
        /// 已经下棋的步数
        /// </summary>
        public int StepNum
        {
            get { return stepNum; }
            set { stepNum = value; }
        }
        /// <summary>
        /// 下一步棋的颜色
        /// </summary>
        public EnumPieceColor NextColor
        {
            get { return nextColor; }
            set { nextColor = value; }
        }        #region 构造函数
        public PieceRoad()
        {
            this.NextColor = EnumPieceColor.black;
        }
        #endregion        #region 清理资源
        public void clear()
        {
            this.pieceArray = new int[15, 15];
            this.road = new List<PieceStep>();
            nextColor = EnumPieceColor.black;
            stepNum = 0;
        }
        #endregion        #region 更换下一步棋颜色
        private void changeColor()
        {
            if (this.nextColor == EnumPieceColor.black)
                this.nextColor = EnumPieceColor.white;
            else
                this.nextColor = EnumPieceColor.black;
        }
        #endregion        #region 将新的一步棋添加到棋盘上
        /// <summary>
        /// 将新的一步棋添加到棋盘上，若棋盘上该位置已有棋子，则返回false
        /// </summary>
        /// <param name="ps">要添加的棋子</param>
        /// <returns>若添加成功则返回true，若棋盘上该位置已有棋子，则返回false</returns>
        public bool Add(PieceStep ps)
        {
            int x = ps.X;
            int y = ps.Y;
            if (pieceArray[x, y] != 0)
            {
                return false;
            }
            else
            {
                pieceArray[x, y] = (int)ps.Color;
                road.Add(ps);
                stepNum++;
                this.changeColor();
                return true;
            }
        }
        #endregion        #region 判断胜利
        public bool Win(PieceStep newPS)
        {
            int x = newPS.X;
            int y = newPS.Y;
            int color = pieceArray[x, y];
            bool win = GetPieceLink(x, y, 0, 1, color);
            win = win|GetPieceLink(x, y, 1, 1, color);
            win = win|GetPieceLink(x, y, 1, 0, color);
            win = win|GetPieceLink(x, y, 1, -1, color);
            return win;
        }
        #endregion        #region 判断某方向上与输入棋子同颜色相连的棋子数
        /// <summary>
        /// 判断某方向上与输入棋子同颜色相连的棋子数
        /// </summary>
        /// <param name="x">输入棋子的x坐标</param>
        /// <param name="y">输入棋子的y坐标</param>
        /// <param name="xIncre">x坐标增量</param>
        /// <param name="yIncre">y坐标增量</param>
        /// <param name="color">棋子颜色</param>
        /// <returns>与输入棋子同颜色相连的棋子数</returns>
        private bool GetPieceLink(int x, int y, int xIncre, int yIncre, int color)
        {
            int Link = 1;
            int Xsearch = x + xIncre;
            int Ysearch = y + yIncre;
            bool stop = false;
            while (Xsearch >= 0 && Xsearch <= 14 && Ysearch >= 0 && Ysearch <= 14 && !stop)
            {
                if (pieceArray[Xsearch, Ysearch] == color)
                {
                    Link++;
                    Xsearch += xIncre;
                    Ysearch += yIncre;
                }
                else
                {
                    stop = true;
                }
            }
            stop = false;
            Xsearch = x-xIncre;
            Ysearch = y-yIncre;
            while (Xsearch >= 0 && Xsearch <= 14 && Ysearch >= 0 && Ysearch <= 14 && !stop)
            {
                if (pieceArray[Xsearch, Ysearch] == color)
                {
                    Link++;
                    Xsearch -= xIncre;
                    Ysearch -= yIncre;
                }
                else
                {
                    stop = true;
                }
            }
            if (Link == 5)
                return true;
            else
                return false;
        }
        #endregion        #region 生成初始棋盘位图
        /// <summary>
        /// 生成初始棋盘位图
        /// </summary>
        /// <returns>初始棋盘位图</returns>
        public Bitmap drawBoard()
        {
            Bitmap broadPaper = new Bitmap(490, 490);
            Graphics myGraphic = Graphics.FromImage(broadPaper);            //黑色画笔
            Pen blackPen = new Pen(Color.Black);
            //SolidBrush yellowBrush = new SolidBrush(Color.Yellow);
            //myGraphic.FillRectangle(yellowBrush, 0, 0, 490, 490);
            //画棋盘外框
            myGraphic.DrawLine(blackPen, 5, 5, 5, 485);
            myGraphic.DrawLine(blackPen, 5, 485, 485, 485);
            myGraphic.DrawLine(blackPen, 485, 485, 485, 5);
            myGraphic.DrawLine(blackPen, 485, 5, 5, 5);
            myGraphic.DrawLine(blackPen, 10, 10, 10, 480);
            myGraphic.DrawLine(blackPen, 15, 480, 480, 480);
            myGraphic.DrawLine(blackPen, 480, 480, 480, 10);
            myGraphic.DrawLine(blackPen, 480, 10, 10, 10);
            //划格线
            int x = 35;
            for (int i = 0; i < 15; i++)
            {
                myGraphic.DrawLine(blackPen, 35, x, 455, x);
                myGraphic.DrawLine(blackPen, x, 35, x, 455);
                x += 30;
            }            return broadPaper;
        }
        #endregion        #region 下一步棋
        /// <summary>
        /// 下一步棋
        /// </summary>
        /// <param name="chessBoard">落子之前的棋盘位图</param>
        /// <param name="x">新下子的x坐标</param>
        /// <param name="y">新下子的y坐标</param>
        /// <param name="nextColor">新下子应有的颜色</param>
        /// <returns>处理完成的新棋盘位图</returns>
        public Bitmap pieceDown(Bitmap chessBoard, int x, int y, EnumPieceColor nextColor)
        {
            if (this.pieceArray[x, y] == 0)
            {
                Graphics myGraphic = Graphics.FromImage(chessBoard);
                //计算坐标
                int xCoordinate = x * 30 + 20;
                int yCoordinate = y * 30 + 20;
                //画棋子
                if (nextColor == EnumPieceColor.black)
                {
                    myGraphic.FillEllipse(new SolidBrush(Color.Black), xCoordinate, yCoordinate, 30, 30);
                }
                else
                {
                    myGraphic.FillEllipse(new SolidBrush(Color.White), xCoordinate, yCoordinate, 30, 30);
                }
            }
            return chessBoard;
        }
        #endregion        #region 重绘棋局
        public Bitmap ReDraw()
        {
            Bitmap newBoard = this.drawBoard();
            Graphics myGraphic = Graphics.FromImage(newBoard);
            SolidBrush blackBrush = new SolidBrush(Color.Black);
            SolidBrush whiteBrush = new SolidBrush(Color.White);
            //计算坐标
            int xCoordinate;
            int yCoordinate;
            foreach (PieceStep ps in road)
            {
                xCoordinate = ps.X * 30 + 20;
                yCoordinate = ps.Y * 30 + 20;
                //画棋子
                if (ps.Color == EnumPieceColor.black)
                {
                    myGraphic.FillEllipse(blackBrush, xCoordinate, yCoordinate, 30, 30);
                }
                else
                {
                    myGraphic.FillEllipse(whiteBrush, xCoordinate, yCoordinate, 30, 30);
                }
            }
            return newBoard;
        }
        #endregion        #region 悔一步棋
        public bool Retract()
        {
            if (stepNum == 0)
            {
                return false;
            }
            else
            {
                stepNum--;//最新一步棋的索引比下子数少1
                PieceStep retractStep = this.road[stepNum];
                int x = retractStep.X;
                int y = retractStep.Y;
                this.pieceArray[x, y] = 0;
                road.RemoveAt(stepNum);
                this.changeColor();
                return true;
            }
        }
        #endregion        #region 绘制两个落子小标志
        public Bitmap DrawMiniPieces(EnumPieceColor miniPiecolor)
        {
            Bitmap miniPiece = new Bitmap(20, 20);
            Graphics myGraphic = Graphics.FromImage(miniPiece);
            if (miniPiecolor == EnumPieceColor.black)
                myGraphic.FillEllipse(new SolidBrush(Color.Black), 0, 0, 20, 20);
            else
                myGraphic.FillEllipse(new SolidBrush(Color.White), 0, 0, 20, 20);
            return miniPiece;
        }
        #endregion
    }
}

Answer 5

using System;
using System.Collections.Generic;
//using System.Linq;
using System.Text;namespace FivePiecesChess
{
    public enum EnumPieceColor
    {
        white = -1,
        black = 1
    }
    class PieceStep
    {
        private int x;
        private int y;
        private int stepNum;
        private EnumPieceColor color;
        /// <summary>
        /// 公有属性，棋子的X坐标
        /// </summary>
        public int X
        {
            get { return x; }
            set { x = value; }
        }
        /// <summary>
        /// 公有属性，棋子的Y坐标
        /// </summary>
        public int Y
        {
            get { return y; }
            set { y = value; }
        }
        /// <summary>
        /// 公有枚举，棋子颜色
        /// </summary>
        public EnumPieceColor Color
        {
            get { return color; }
            set { color = value; }
        }
        /// <summary>
        /// 一步棋
        /// </summary>
        /// <param name="x">棋子的x坐标</param>
        /// <param name="y">棋子的y坐标</param>
        /// <param name="stepNum">这一步是第几步棋</param>
        /// <param name="color">棋子颜色</param>
        public PieceStep(int x, int y, int stepNum, EnumPieceColor color)
        {
            this.x = x;
            this.y = y;
            this.stepNum = stepNum;
            this.color = color;
        }    }
}