Silverlight+WCF 新手实例象棋棋子移动-规则[将、马、士、相、炮](八)

最新推荐文章于 2023-01-11 19:15:00 发布

weixin_33796177

最新推荐文章于 2023-01-11 19:15:00 发布

阅读量161

点赞数

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/secyaher/blog/274084

本文详细解析了象棋中各种棋子（将、马、士、相、炮）的移动规则实现，包括如何判断走法是否合法，如马的‘日’字形走法和炮的隔子打炮特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

为什么80%的码农都做不了架构师？>>>

这节来完成剩下五个种子的规则。

先来将吧

将：只能走一步，而且只能在九宫内行走

看代码，还是和兵的一个样。

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

下面限制九宫内判断：

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

完了，将的验证太简单了，句合起来就是：

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

下面说马，爱日的马。

马：有两种走法，一种竖着日,一种横着日，如果没有顶心顶肺马脚就日过去了。

先说竖着日,y方向走跨两步，x方向跨一步,是不是很简单：

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

那马脚咋判断？我们只要判断马脚上存不存在棋子就可以了，至于马脚点的坐标，

其实就是：（x1 + x2) / 2, y1，y不变，x方向和移动点之间的点。

要判断棋子存不存在呢，我们要加多个函数来判断了。

/// <summary>
         /// 是否存在指定的点
         /// </summary>
         public bool IsExits(Point point)
        {//待实现

return true;
}

好了，现在我们在马日里实现马脚判断就行了：

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

这样就完成竖着日，横着日嘛，也很简单了，y方向一步，x方向两步：

代码

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

两个合起来嘛，完整代码就是：

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 ;

下面说说士啦[上面那个点的判断后面再实现，其实就是一个循环棋子找点]

士：九宫内走半日。

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搞定了。

下面说说相：

相：走两日合成田，不能有马脚，还不能过河。

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。好，先调用和车一样的障碍物函数：

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

2。判断是不是目标地点有“炮可打”

bool exits = IsExits(moveTo);

3。最后进行判断，看下面那句说明：

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

合起来就是：

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

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

OK，至此，所以规则都做完了，oh,还有一个判断马脚田脚和猪脚的函数没实现，现在来实现一下：

由于根据一个点找一颗棋子，这函数是在以后会用到，所以，我们在Chess类里先实现一个函数来返回一颗棋子：

/// <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 ;
        }

接下我们那个IsExits函数就相当的简单了：

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

终于，该做的都做完了，我们对下半盘棋子都做了规则限制了。

那我们到现在还没应用呢，应用呢，很简单了，回到动作类里ChessAction里，在MoveTo方法加一个if判断就行了

/// <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，运行看下效果：