澳门娱乐官网授权新建棋子规则类,而且不得不在九宫内行动

上两节完毕了棋子的二种走法,吃子和没移动到线交叉点。但是大家都以没有规则的走,那节为棋子的走法扩张规则,棋的条条框框自身就不多说了,基本要找个不会下象棋的很难,就是找到的猜想也不会看那小说。

那节来形成剩余五个种子的条条框框。

 

先来将吧

当大家移动棋子的时候,总是要判断一下平移是否合规则的,合规则的才让下,违规则的就无法下了,什么马象田马日车炮跑,将军卫士陷九宫,[本身涅造句子]之类的。

将:只好走一步,而且只辛亏九宫内行动

好了,原始冲动,新建棋子规则类,也是本棋子裤的结尾3个类了:

看代码,照旧和兵的多个样。

对着项目三角裤右键-》添加类->输入:ChessRule.cs。

if (Math.Abs(y2 – y1) + Math.Abs(x2 – x1) != 1)//只好走一步
                        {
                            break;
                        }

/// <summary>
    /// 棋子规则-by 路过金秋
    /// </summary>
    public class ChessRule
    {

 

    }

下边限制九宫内判断:

 

if (2 < x2 && x2 < 6 && y2 > 6)
                            {
                                return true;
                            }

我们为之新增添一个方式IsCanMove方法,正是棋子要走的时候,用此措施来判定是或不是吻合规则,再次回到值就是bool型了。

 

澳门娱乐官网授权 1澳门娱乐官网授权 2

完了,将的求证太不难了,句合起来正是:

/// <summary>
    /// 棋子规则-by 路过金秋
    /// </summary>
    public class ChessRule
    {
        /// <summary>
        /// 移动规则
        /// </summary>
        /// <param name=”move”>棋子</param>
        /// <param name=”eat”>移动的岗位的数组</param>
        /// <returns></returns>
        public bool IsCanMove(Chessman chessman, Point moveTo)
        {
            //完成判断
            return false;
        }
    }

澳门娱乐官网授权 3澳门娱乐官网授权 4

 

 case ChessType.Jiang:
                        if (Math.Abs(y2 – y1) + Math.Abs(x2 – x1) != 1)//只可以走一步
                        {
                            break;
                        }
                        if (2 < x2 && x2 < 6 && y2 > 6)
                        {
                            //九宫内走
                            return true;
                        }
                        break;

每种棋子都有独家的平整,由此大家要用Switch来分支,这里大家在类的外界加上个棋子枚举:

 

public enum ChessType
    {
        Bing,
        Pao,
        Che,
        Ma,
        Xiang,
        Shi,
        Jiang
    }

上边说马,爱日的马。

 

马:有二种走法,一种竖着日,一种横着日,假设没有顶心顶肺马脚就日过去了。

懂点粤语的一看就知道那E文是何许意思了。

先说竖着日,y方向走跨两步,x方向跨一步,是还是不是非常粗大略:

好,大家为规则ChessRule类再加个方法,通过棋子的称谓来回到ChessType

if ((Math.Abs(y2 – y1) == 2 && Math.Abs(x2 – x1) == 1))//先判断走竖日型
{
//再判断有没有漏洞。
}

澳门娱乐官网授权 5澳门娱乐官网授权 6

 

 public ChessType GetChessTypeByName(string name)
        {
            switch (name)
            {
                case “兵”:
                case “卒”:
                    return ChessType.Bing;
                case “炮”:
                    return ChessType.Pao;
                case “车”:
                    return ChessType.Che;
                case “马”:
                    return ChessType.Ma;
                case “士”:
                case “仕”:
                    return ChessType.Shi;
                case “将”:
                case “帅”:
                    return ChessType.Jiang;
                case “象”:
                case “相”:
                    return ChessType.Xiang;
            }
            throw new Exception(“未有名称:” + name);
        }

那尾巴咋判断?大家假如判断马脚上存不存在棋子就足以了,至于马脚点的坐标,

OK,那时候我们再修改下IsCanMove方法就能改成这么了:

事实上正是:(x1 + x2) / 2, y1,y不变,x方向和移动点之间的点。

澳门娱乐官网授权 7澳门娱乐官网授权 8

要咬定棋子存不设有吗,大家要加多少个函数来判断了。

 public bool IsCanMove(Chessman chessman, Point moveTo)
        {
            //完成判断
            ChessType chessType=GetChessTypeByName(chessman.Name);
            switch (chessType)
            {
                case ChessType.Bing:
                    //待实现
                    break;
                case ChessType.Che:
                    //待实现
                    break;
                case ChessType.Jiang:
                    //待实现
                    break;
                case ChessType.Ma:
                    //待实现
                    break;
                case ChessType.Shi:
                    //待实现
                    break;
                case ChessType.Xiang:
                    //待实现
                    break;
                case ChessType.Pao:
                    //待实现
                    break;
            }
            return false;
        }

 /// <summary>
        /// 是或不是留存钦赐的点
        /// </summary>
        public bool IsExits(Point point)
        {//待实现

 

            return true;
        }

那边扩充了八个枚举和章程取得来开始展览分层,假若嫌麻烦了,就用加枚举了,直接在里面

 

Swith(chessman.Name){

好了,未来大家在马日里实现马脚判断就行了:

case “兵”: case “卒”: //待实现

澳门娱乐官网授权 9澳门娱乐官网授权 10

case “将”: case “帅”: //待现

if ((Math.Abs(y2 – y1) == 2 && Math.Abs(x2 – x1) == 1))//先判断走竖日型
                        {
                            //有没有马脚点
                            if (!IsExits(new Point(x1, (y1 + y2) / 2)))
                            {
                                return true;
                            }
                        }

case “车”: case “帅”: //待现

 

case “炮”: //待实现

诸如此类就完事竖着日,横着日嘛,也很简短了,y方向一步,x方向两步:

}

澳门娱乐官网授权 11澳门娱乐官网授权 12代码

这么也是行的。

if ((Math.Abs(y2 – y1) == 1 && Math.Abs(x2 – x1) == 2))//先判断走横日型
                        {
                            //有没有马脚点
                            if (!IsExits(new Point((x1 + x2) / 2, y1)))
                            {
                                return true;
                            }
                        }

好了,未来开班步步二个3个的贯彻规则。

 

我们先把多少个坐标拿出来弄为x1,y1,x2,y2先,然后开始展览第3步判断,尽管移动的职位超出棋盘范围以内,只怕原地走就不肯,于是代码不难的成为:

四个合起来嘛,完整代码就是:

由于棋盘有九条直线,十条横线,对应到x,y坐标的界定正是x->(0,8)
y->(0,9),原地的话便是(x1,y1)点=(x2,y2)点

澳门娱乐官网授权 13澳门娱乐官网授权 14

澳门娱乐官网授权 15澳门娱乐官网授权 16

case ChessType.Ma:
                        if ((Math.Abs(y2 – y1) == 2 && Math.Abs(x2 – x1) == 1))//先判断走竖日型
                        {
                            //有没有马脚点
                            if (!IsExits(new Point(x1, (y1 + y2) / 2)))
                            {
                                return true;
                            }
                        }
                        else if ((Math.Abs(y2 – y1) == 1 && Math.Abs(x2 – x1) == 2))//先判断走横日型
                        {
                            //有没有马脚点
                            if (!IsExits(new Point((x1 + x2) / 2, y1)))
                            {
                                return true;
                            }
澳门娱乐官网授权,                        }
                        break;

 public bool IsCanMove(Chessman chessman, Point moveTo)
        {
            //完毕判断
            int x1 = (int)chessman.MovePoint.X;
            int y1 = (int)chessman.MovePoint.Y;
            int x2 = (int)moveTo.X;
            int y2 = (int)moveTo.Y;
            if (x2 >= 0 && x2 < 9 && y2 >= 0 && y2 < 10 && !(x1 == x2 && y1 == y2))//在棋盘之内,非原步。
            {
                ChessType chessType = GetChessTypeByName(chessman.Name);
                switch (chessType)
                {
                    case ChessType.Bing:
                        //待实现
                        break;
                    case ChessType.Che:
                        //待实现
                        break;
                    case ChessType.Jiang:
                        //待实现
                        break;
                    case ChessType.Ma:
                        //待实现
                        break;
                    case ChessType.Shi:
                        //待实现
                        break;
                    case ChessType.Xiang:
                        //待实现
                        break;
                    case ChessType.Pao:
                        //待实现
                        break;
                }
            }
            return false;
        }

 

 OK,今后来开头兑现率先个兵规则。其实一开首自笔者想啊想:

上边说说士啦[地方10分点的判断后边再落到实处,其实正是1个循环往复棋子找点]

兵:没过河,只好往前走,过了河,只好直走和横着走。而且每回只可以走一步

士:九宫内走半日。

好,一步一步限制。

澳门娱乐官网授权 17澳门娱乐官网授权 18

1.先判断一下是否走一步

 case ChessType.Shi:
                        if (2 < x2 && x2 < 6 && y2 > 6)
                        {
                            //九宫内走
                            if ((Math.Abs(y2 – y1) == 1 && Math.Abs(x2 – x1) == 1))//半日
                            {
                                return true;
                            }
                        }
                        break;

if (Math.Abs(y2 – y1) + Math.Abs(x2 – x1) != 1)//只好走一步
                        {
                            break;
                        }

 

 

完了,两个if搞定了。

由于咱们首先个判断限制只可以走一步,接大家来判断一下棋子是或不是往前直走。

下边说说相:

if(x1 == x2 && y1 > y2){return true;}

相:走二日合成田,不可能有尾巴,还不能够过河。

接下去大家判断一下棋子是横着走,并且过了河。

澳门娱乐官网授权 19澳门娱乐官网授权 20

if(y1 == y2 && y1 < 5){return true;}

case ChessType.Xiang:
                        if ((Math.Abs(y2 – y1) == 2 && Math.Abs(x2 – x1) == 2))//先判断走田型
                        {
                            //有没有田脚点,并且不可能过河
                            if (!IsExits(new Point((x1 + x2) / 2, (y1 + y2) / 2)))
                            {
                                if (y2 > 4)//不过河
                                {
                                    return true;
                                }
                            }
                        }
                        break;

鉴于下棋者,不奇怪都只用位于棋子下方的棋的,所以只要判断下边包车型地铁棋类的规则就行了。

 

[备考,当然了,假如您想对地点的棋子也开始展览潜规则,也是能够的,待讲完发完整代码时再对地点的棋类进行不成文规定]

三步判断解决。

好了,将后边多少个合起来,完整的代码就是:

下边最终1个正是炮了:

澳门娱乐官网授权 21澳门娱乐官网授权 22

炮:能和车一模一样直来直往。仍可以够隔空打炮,可是只可以隔一炮打一炮,即隔着炮的时候必须有炮给打,尽管没东西打就无法过去。

 case ChessType.Bing:
                        if (Math.Abs(y2 – y1) + Math.Abs(x2 – x1) != 1)//只好走一步
                        {
                            break;
                        }
                        if ((x1 == x2 && y1 > y2) || (y1 == y2 && y1 < 5))
                        {//只好直走 恐怕 过了河左右走
                            return true;
                        }
                        break;

1。好,先调用和车同样的障碍物函数:

 

OutCount(chessman.MovePoint, moveTo, out xCount, out yCount);

看,二个兵的规则,咋家用多少个if化解了。看来,规则判断也不是那么难的。

2。判断是或不是目的地方有“炮可打”

好,下一个是怎么啊?车

bool exits = IsExits(moveTo);

车:能够直走或横着走,不可能通过棋子,吃倒是能够,自家颜色不给吃[其一大家在外围点击棋子就有咬定等于切换棋子了]

3。最终进行判定,看上面那句表达:

自作者想了想,想出八个主意,获取一颗棋子原始点和移动到的点之间在X和Y方向的障碍物[就算有几颗棋子顶着个肺]

if (x1 == x2 && (yCount == 0 && !exits) || (yCount == 1 && exits)
                         || y1 == y2 && (xCount == 0 && !exits) ||
(xCount == 1 && exits))
                        {//坚走/横走没有最多一个障碍别
                            return true;
                        }

一方法又生出了:

合起来正是:

澳门娱乐官网授权 23澳门娱乐官网授权 24

 

 /// <summary>
        /// 获取障碍物数量
        /// </summary>
        public void OutCount(Point start, Point end, out int xCount, out int yCount)
        {
            xCount = 0;
            yCount = 0;
            //待实现
        }

澳门娱乐官网授权 25澳门娱乐官网授权 26

 

 case ChessType.Pao:
                        OutCount(chessman.MovePoint, moveTo, out xCount, out yCount);
                        bool exits = IsExits(moveTo);

好,有了这么些措施,车子的活动规则就12分的几乎了,看下表达就知晓了:

                        if (x1 == x2 && (yCount == 0 && !exits) || (yCount == 1 && exits)
                         || y1 == y2 && (xCount == 0 && !exits) || (xCount == 1 && exits))
                        {//坚走/横走没有最多多个障碍别
                            return true;
                        }
                        break;

澳门娱乐官网授权 27澳门娱乐官网授权 28

 

case ChessType.Che:
                         int xCount, yCount;
                        OutCount(chessman.MovePoint, moveTo, out xCount, out yCount);
                        if (x1 == x2 && yCount == 0 || y1 == y2 && xCount == 0)
                        {//坚走/横走没有障碍别
                            return true;
                        }
                        break;

OK,至此,所以规则都做完了,oh,还有2个断定马脚田脚和猪脚的函数没达成,今后来完成一下:

 

鉴于依据五个点找一颗棋子,那函数是在随后会用到,所以,大家在Chess类里先完成三个函数来回到一颗棋子:

没想到车子的移位规则也变的那样不难了。

澳门娱乐官网授权 29澳门娱乐官网授权 30

呵呵,那么些获取障碍物的格局还平昔不达成吗

/// <summary>
        /// 找棋子
        /// </summary>
        public Chessman FindChessman(Point point)
        {
            for (int i = 0; i < ChessmanList.Count; i++)
            {
                if (point == ChessmanList[i].MovePoint)
                {
                    return ChessmanList[i];
                }
            }
            return null;
        }

接下去贯彻一下啊,那里我们要为棋子规则ChessRule类引入三个构造函数,为何要引入Action呢,因为运动规则唯有在移动的时候才出现出来闪一下。其余时候规则是退隐江湖的。

 

澳门娱乐官网授权 31澳门娱乐官网授权 32

接到大家更加IsExits函数就卓殊的简便了:

 /// <summary>
        /// 动作类
        /// </summary>
        public ChessAction Action
        {
            get;
            set;
        }
        public ChessRule(ChessAction action)
        {
            Action = action;
        }

/// <summary>
        /// 是还是不是存在内定的点
        /// </summary>
        public bool IsExits(Point point)
        {
            return Action.Parent.FindChessman(point) != null;
        }

 

 

既是构造里引入ChessAction,同样,在ChessAction里也得实例化下那一个ChessRule,不然怎么将自个儿传过来啊。

好不不难,该做的都做完了,大家对下半盘棋子都做了平整限制了。

回来ChessAction的构造函数,同时加一属性:

那我们到今后还没利用呢,应用呢,很简短了,回到动作类里ChessAction里,在MoveTo方法加三个if判断就行了

澳门娱乐官网授权 33澳门娱乐官网授权 34

 

public ChessRule Rule//新加的质量
        {
            get;
            set;
        }
        public ChessAction(Chess ownChess)
        {
            OwnChess = ownChess;
            Rule = new ChessRule(this);//新加的实例化
        }

澳门娱乐官网授权 35澳门娱乐官网授权 36

 

/// <summary>
        /// 移动棋子
        /// </summary>
        /// <param name=”chessman”>棋子</param>
        /// <param name=”toX”>移动到X坐标</param>
        /// <param name=”toY”>移动到Y坐标</param>
        public bool MoveTo(Chessman chessman, Point moveTo)
        {
            if (Rule.IsCanMove(chessman, moveTo))//把规则应用到此地就OK了
            {
                chessman.ReadyMove = false;
                chessman.chessman.Background = null;
                PlayMove(chessman, moveTo);
                chessman.MovePoint = moveTo;
                return true;
            }
            return false;
        }

OK,今后得以兑现丰富获取障碍物棋子数的艺术了:

 

 

OK,运营看下效果:

澳门娱乐官网授权 37澳门娱乐官网授权 38

澳门娱乐官网授权 39

 /// <summary>
        /// 获取障碍物数量
        /// </summary>
        public void OutCount(Point start, Point end, out int xCount, out int yCount)
        {
            xCount = yCount = 0;
            Point point;
            for (int i = 0; i < Action.Parent.ChessmanList.Count; i++)
            {
                point = Action.Parent.ChessmanList[i].MovePoint;
                if (start.Y == point.Y && Math.Min(start.X, end.X) < point.X && point.X < Math.Max(start.X, end.X))
                {
                    xCount++;
                }
                if (start.X == point.X && Math.Min(start.Y, end.Y) < point.Y && point.Y < Math.Max(start.Y, end.Y))
                {
                    yCount++;
                }
            }
        }

试了一下,上边包车型地铁革命棋都寻常的按规则走了。

 

可是上半棋浅紫棋,依旧分别的是不可能按规则走,不过大家下棋都一般只下上边包车型客车棋,所以选择的话只对下半盘做限定就行了。

 

要是需求对上半盘也做限定,其它格局补给了。

微小解说一下:

好到这一品级,提供第叁品级源码:点击下载

1。遍历全部的棋子的坐标

打完收工!

2。start.Y==point.Y时,表达是Y坐标相同,便是横线上的可比

作者博客:http://cyq1162.cnblogs.com/

3。start.X==point.X时,表明是X坐标相同,正是直线上的比较

4。接下来就是起始点[最小值]<被遍历棋子坐标<终点[最大值],在那其间的棋子数正是障碍物数量了。

末尾,把尤其重临值暗中认可重临return false;

如今完全代码如下:

 

澳门娱乐官网授权 40澳门娱乐官网授权 41

public enum ChessType
    {
        Bing,
        Pao,
        Che,
        Ma,
        Xiang,
        Shi,
        Jiang
    }
    /// <summary>
    /// 棋子规则-by 路过高商
    /// </summary>
    public class ChessRule
    {
        /// <summary>
        /// 动作类
        /// </summary>
        public ChessAction Action
        {
            get;
            set;
        }
        public ChessRule(ChessAction action)
        {
            Action = action;
        }
        /// <summary>
        /// 移动规则
        /// </summary>
        /// <param name=”move”>棋子</param>
        /// <param name=”eat”>移动的岗位的数组</param>
        /// <returns></returns>
        public bool IsCanMove(Chessman chessman, Point moveTo)
        {
            //完成判断
            int x1 = (int)chessman.MovePoint.X;
            int y1 = (int)chessman.MovePoint.Y;
            int x2 = (int)moveTo.X;
            int y2 = (int)moveTo.Y;
            if (x2 >= 0 && x2 < 9 && y2 >= 0 && y2 < 10 && !(x1 == x2 && y1 == y2))//在棋盘之内,非原步。
            {
                ChessType chessType = GetChessTypeByName(chessman.Name);
                switch (chessType)
                {
                    case ChessType.Bing:
                        if (Math.Abs(y2 – y1) + Math.Abs(x2 – x1) != 1)//只可以走一步
                        {
                            break;
                        }
                        if ((x1 == x2 && y1 > y2) || (y1 == y2 && y1 < 5))
                        {//只可以直走 或然 过了河左右走
                            return true;
                        }
                        break;
                    case ChessType.Che:
                         int xCount, yCount;
                        OutCount(chessman.MovePoint, moveTo, out xCount, out yCount);
                        if (x1 == x2 && yCount == 0 || y1 == y2 && xCount == 0)
                        {//坚走/横走没有障碍别
                            return true;
                        }
                        break;
                    case ChessType.Jiang:
                        //待实现
                        break;
                    case ChessType.Ma:
                        //待实现
                        break;
                    case ChessType.Shi:
                        //待实现
                        break;
                    case ChessType.Xiang:
                        //待实现
                        break;
                    case ChessType.Pao:
                        //待实现
                        break;
                }
            }
            return false;
        }
        public ChessType GetChessTypeByName(string name)
        {
            switch (name)
            {
                case “兵”:
                case “卒”:
                    return ChessType.Bing;
                case “炮”:
                    return ChessType.Pao;
                case “车”:
                    return ChessType.Che;
                case “马”:
                    return ChessType.Ma;
                case “士”:
                case “仕”:
                    return ChessType.Shi;
                case “将”:
                case “帅”:
                    return ChessType.Jiang;
                case “象”:
                case “相”:
                    return ChessType.Xiang;
            }
            throw new Exception(“未出名称:” + name);
        }
        /// <summary>
        /// 获取障碍物数量
        /// </summary>
        public void OutCount(Point start, Point end, out int xCount, out int yCount)
        {
            xCount = yCount = 0;
            Point point;
            for (int i = 0; i < Action.Parent.ChessmanList.Count; i++)
            {
                point = Action.Parent.ChessmanList[i].MovePoint;
                if (start.Y == point.Y && Math.Min(start.X, end.X) < point.X && point.X < Math.Max(start.X, end.X))
                {
                    xCount++;
                }
                if (start.X == point.X && Math.Min(start.Y, end.Y) < point.Y && point.Y < Math.Max(start.Y, end.Y))
                {
                    yCount++;
                }
            }
        }    }

 

OK,那节先完成兵和车的规则,下小节再落实其他棋子规则。

 打完,收工!

作者博客:http://cyq1162.cnblogs.com/