分类导航

silverlight 发布时间：2022-05-04 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了Silverlight+WCF 新手实例象棋棋子移动-规则[兵、车](七)，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

概述

转帖地址：http://www.cnblogs.com/cyq1162/archive/2010/07/09/1774210.html 上两节实现了棋子的两种走法，吃子和没移动到线交叉点。不过我们都是没有规则的走，这节为棋子的走法增加规则，棋的规则@R_663_6963@，基本要找个不会下象棋的很难，就是找到的估计也不会看这文章。当我们移动棋子的时候，总是要判断一下移动是不是合规则的，合规则的才让下

转帖地址：http://www.cnblogs.com/cyq1162/archive/2010/07/09/1774210.html

上两节实现了棋子的两种走法，吃子和没移动到线交叉点。不过我们都是没有规则的走，这节为棋子的走法@L_674_0@规则，棋的规则@R_663_6963@，基本要找个不会下象棋的很难，就是找到的估计也不会看这文章。

当我们移动棋子的时候，总是要判断一下移动是不是合规则的，合规则的才让下，不合规则的就不能下了，什么马象田马日车炮跑，将军卫士陷九宫，[本人涅造句子]之类的。

好了，原始冲动，新建棋子规则类，也是本棋子裤的最后一个类了：

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

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

    }

我们为之新@L_674_0@一个方法IsCanMove方法，就是棋子要走的时候，用此方法来判断是不是符合规则，返回值就是bool型了。

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

每种棋子都有各自的规则，因此我们要用Switch来分支，这里我们在类的外面加上个棋子枚举：

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

懂点汉语的一看就知道这E文是什么意思了。

好，我们为规则ChessRule类再加个方法，通过棋子的名称来返回ChessType

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方法就能改成这样了：

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

这里@L_674_0@了一个枚举和方法获取来进行分支，要是嫌麻烦了，就用加枚举了，直接在里面

Swith(chessman.Name){

case "兵": case "卒": //待实现

case "将": case "帅": //待现

case "车": case "帅": //待现

case "炮": //待实现

}

这样也是行的。

好了，现在开始步步一个一个的实现规则。

我们先把几个坐标拿出来弄为x1,y1,x2,y2先，然后进行第一步判断，如果移动的位置超出棋盘范围之内，或者原地走就拒绝，于是代码简单的变成：

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

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 >= @H_786_772@0 && x2 < @H_786_772@9 && y2 >= @H_786_772@0 && y2 < @H_786_772@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，现在来开始实现第一个兵规则。其实一开始我想啊想：

兵：没过河，只能往前走，过了河，只能直走和横着走。而且每次只能走一步

好，一步一步限制。

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

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

由于我们第一个判断限制只能走一步，接我们来判断一下棋子是不是往前直走。

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

接下来我们判断一下棋子是横着走，并且过了河。

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

由于下棋者，正常都只用位于棋子下方的棋的，所以只要判断下面的棋子的规则就行了。

[备注，当然了，如果你想对上面的棋子也进行潜规则，也是可以的，待讲完发完整代码时再对上面的棋子进行潜规则]

好了，将后面两个合起来，完整的代码就是：

case ChessType.bing:
                         if (Math.Abs(y2 - y1) + Math.Abs(x2 - x1) != @H_786_772@1 ) // 只能走一步
                         {
                             break ;
                        }
                         if ((x1 == x2 && y1 > y2) || (y1 == y2 && y1 < @H_786_772@5 ))
                        { // 只能直走或者过了河左右走
                              return true ;
                        }
                         break ;

看，一个兵的规则，咋家用两个if搞定了。看来，规则判断也不是那么难的。

好，下一个是什么呢？车

车：能够直走或横着走，不能越过棋子，吃倒是可以，自家颜色不给吃[这个我们在外面点击棋子就有判断等于切换棋子了]

我想了想，想出一个方法，获取一颗棋子原始点和移动到的点之间在X和Y方向的障碍物[就是有几颗棋子顶着个肺]

一方法又产生了:

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

好，有了这个方法，车子的移动规则就相当的简单了，看下说明就清楚了：

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

没想到车子的移动规则也变的这么简单了。

呵呵，那个获取障碍物的方法还没有实现呢

接下来实现一下吧,这里我们要为棋子规则ChessRule类引入一个构造函数,为什么要引入Action呢，因为移动规则只有在移动的时候才现身出来闪一下。其它时候规则是退隐江湖的。

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

既然构造里引入ChessAction，同样，在ChessAction里也得实例化下这个ChessRule，不然怎么将自身传过来啊。

回到ChessAction的构造函数，同时加一属性：

public ChessRule rule // 新加的属性
         {
             get ;
             set ;
        }
         public ChessAction(Chess ownChess)
        {
            OwnChess = ownChess;
            rule = new ChessRule( this ); // 新加的实例化
        }

OK，现在可以实现那个获取障碍物棋子数的方法了：

/// <sumMary>
         /// 获取障碍物@L_607_33@
         /// </sumMary>
         public void OutCount(Point start, out int yCount)
        {
            xCount = yCount = @H_786_772@0 ;
            Point point;
             for ( int i = @H_786_772@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坐标相同，就是横线上的比较

3。start.X==point.X时，说明是X坐标相同，就是直线上的比较

4。接下来就是起始点[最小值]<被遍历棋子坐标<终点[最大值],在这里面的棋子数就是障碍物@L_607_33@了。

最后，把那个返回值默认返回return false;

目前完整代码如下：

public enum ChessType
    {
        Bing,
        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,非原步。
            {
                ChessType chessType = GetChessTypeByName(chessman.Name);
                 switch (chessTypE)
                {
                     case ChessType.bing:
                         if (Math.Abs(y2 - y1) + Math.Abs(x2 - x1) != @H_786_772@1 ) // 只能走一步
                         {
                             break ;
                        }
                         if ((x1 == x2 && y1 > y2) || (y1 == y2 && y1 < @H_786_772@5 ))
                        { // 只能直走或者过了河左右走
                              return true ;
                        }
                         break ;
                     case ChessType.Che:
                          int xCount, out yCount);
                         if (x1 == x2 && yCount == @H_786_772@0 || y1 == y2 && xCount == @H_786_772@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>
         /// 获取障碍物@L_607_33@
         /// </sumMary>
         public void OutCount(Point start, end.Y))
                {
                    yCount ++ ;
                }
            }
        }    }

OK，这节先实现兵和车的规则，下小节再实现其它棋子规则。

打完，收工！

大佬总结

以上是大佬教程为你收集整理的Silverlight+WCF 新手实例象棋棋子移动-规则[兵、车](七)全部内容，希望文章能够帮你解决Silverlight+WCF 新手实例象棋棋子移动-规则[兵、车](七)所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。

标签：silverlight silverlight+wcf wcf 七兵实例新手棋子移动规则象棋车

上一篇: Silverlight+WCF 新手实例象棋 ... 下一篇:Silverlight+WCF 新手实例象棋 ...

猜你在找的silverlight相关文章

silverlight – 如何在Windows Phone 7中创建连续动画？ 2022-05-04
wpf – 嵌入图像在UserControl中不显示 2022-05-03
WPF的Deepzoom 2022-05-03
silverlight – 设置ComboBoxItem的文本和值 2022-05-03
wpf – 寻找股票图表组件 2022-05-03
如何在Silverlight中以编程方式转到特定的URL？ 2022-05-03
Silverlight Webservice“远程服务器返回错误：NotFound” 2022-05-03
osx – 无法输入Silverlight 5输入字段(Chrome)MacOS 2022-05-03
客户端WCF DataContract具有来自服务的空/空值 2022-05-03
使用MVVM Light Messenger与Silverlight 4 ChildWindow对话框类 2022-05-03

Silverlight+WCF 新手实例 象棋 棋子移动-规则[兵、车](七)

概述

大佬总结

Silverlight+WCF 新手实例象棋棋子移动-规则[兵、车](七)