象棋游戏编程——各棋子的走法

BingWay原创作品，转载请注明作者和出处。

继上次写的《象棋游戏编程——画棋盘》，经过十一长假的几天休息和调整，这几天终于把各棋子的走法功能完成。

象棋的走法是玩象棋必须知道的，下面的走法是我玩象棋两三天过后总结的。

将或帅 

移动范围：它只能在王宫内移动。 

移动规则：它每一步只可以水平或垂直移动一点。
士
移动范围：它只能在王宫内移动。
移动规则：它每一步只可以沿对角线方向移动一点。
象
移动范围：河界的一侧。
移动规则：它每一步只可以沿对角线方向移动两点(象走田)，另外，在移动的过程中不能够穿越障碍，如果有，就是俗称的“塞象”。
马
移动范围：任何位置
移动规则：每一步只可以水平或垂直移动一点(马走日)，再按对角线方面向左或者右移动。另外，在移动的过程中不能够穿越障碍，如果有，就是俗称的“撇马脚”。
车
移动范围：任何位置
移动规则：可以水平或垂直方向移动任意个无阻碍的点。
炮
移动范围：任何位置
移动规则：移动起来和车很相似，但它必须跳过一个棋子来吃掉对方的一个棋子(隔山炮)。
兵
移动范围：任何位置
移动规则：每步只能向前移动一点。小兵过河后，就有了左右移动的能力，兵只能前进，不能后退。

实现各棋子走法的代码：

  1  //判断***马***的走法是否合理
  2 public bool HorseFoot(Point fromPoint,Point toPoint)
  3         {
  4             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
  5             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引
  6             if(fromPoint==toPoint)  //如果起点和终点是同一个点,则允许放回旗子,重新选其它路
  7             {                
  8                 return true;
  9             }
 10             
 11             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能走
 12             {                
 13                 return false;            
 14             }
 15             double twoPoint_Right_Distance=Math.Sqrt((this.width*this.width)+(width+width)*(width+width));
 16             double twoPoint_True_Distance=Math.Sqrt((fromPoint.X-toPoint.X)*(fromPoint.X-toPoint.X)+(fromPoint.Y-toPoint.Y)*(fromPoint.Y-toPoint.Y));
 17             if(this.GetNextPoint(fromPoint,-2,1)==toPoint||this.GetNextPoint(fromPoint,-2,-1)==toPoint)  //当马向上跳时有两种跳法(左上日和右上日)
 18                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,-1,0))]==false)   //起点上面没有旗子,也就是不 "撇马脚" 时可以往上走旗
 19                 {                    
 20                     if(twoPoint_True_Distance<=twoPoint_Right_Distance)
 21                         return true;
 22                 }
 23             if(this.GetNextPoint(fromPoint,2,1)==toPoint||this.GetNextPoint(fromPoint,2,-1)==toPoint)   //同上,只是变为向下跳马的情况
 24                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,1,0))]==false)
 25                 {                    
 26                     if(twoPoint_True_Distance<=twoPoint_Right_Distance)
 27                         return true;                    
 28                 }
 29             if(this.GetNextPoint(fromPoint,1,2)==toPoint||this.GetNextPoint(fromPoint,-1,2)==toPoint)   //同上,只是变为向右跳马的情况
 30                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,0,1))]==false)
 31                 {                    
 32                     if(twoPoint_True_Distance<=twoPoint_Right_Distance+5)
 33                         return true;
 34                 }
 35             if(this.GetNextPoint(fromPoint,-1,-2)==toPoint||this.GetNextPoint(fromPoint,1,-2)==toPoint) //同上,只是变为向左跳马的情况
 36                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,0,-1))]==false)
 37                 {                    
 38                     if(twoPoint_True_Distance<=twoPoint_Right_Distance+5)
 39                         return true;            
 40                 }
 41             
 42             return false;    //除去以上几种情况,其余终点都不能落旗            
 43         }
 44         //判断***兵/卒***的走法是否合理
 45         public bool ObiitFoot(Point fromPoint,Point toPoint)
 46         {            
 47             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
 48             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引
 49             string isUpOrDownFromPoint=this.IsUpOrDown(fromPoint); //起点是在旗盘上方,还是下方("兵/帅" 在旗子上方和下方走法不一样) 
 50             string isUpOrDownToPoint=this.IsUpOrDown(toPoint);     //终点是在旗盘上方,还是下方("兵/帅" 在旗子上方和下方走法不一样)
 51             
 52             if(fromPoint==toPoint)  //如果起点和终点是同一个点,则允许放回旗子,重新先其它路
 53             {                
 54                 return true;
 55             }
 56             
 57             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能走
 58             {                
 59                 return false;            
 60             }
 61 
 62             if(who[fromIndex].Equals("black"))  //假如起始点是黑兵
 63             {    
 64                 if(isUpOrDownFromPoint=="down"&&isUpOrDownToPoint=="down"||isUpOrDownFromPoint=="down"&&isUpOrDownToPoint=="up")//起点和终点都在下面或起点在下面终点在上面时情况
 65                 {                    
 66                     if(this.GetNextPoint(fromPoint,-1,0)==toPoint)  //如果终点是起点的上面一个点,则返回真
 67                     {                        
 68                         return true;
 69                     }
 70                 }
 71                 else
 72                 {
 73                     if(isUpOrDownFromPoint=="up"&&isUpOrDownToPoint=="up")//当起点和终点都在同一点
 74                     {
 75                         if(this.GetNextPoint(fromPoint,-1,0)==toPoint) //过河后可以往上走
 76                             return true;
 77                          if(this.GetNextPoint(fromPoint,0,1)==toPoint)  //过河后可以往右走
 78                             return true;
 79                         if(this.GetNextPoint(fromPoint,0,-1)==toPoint) //过河后可以往左走
 80                             return true;
 81                     }
 82                 }                
 83             }
 84             if(who[fromIndex].Equals("red"))
 85             {                
 86                 if(isUpOrDownFromPoint=="up"&&isUpOrDownToPoint=="up"||isUpOrDownFromPoint=="up"&&isUpOrDownToPoint=="down")
 87                 {                    
 88                     if(this.GetNextPoint(fromPoint,1,0)==toPoint)
 89                     {                        
 90                         return true;
 91                     }
 92                 }
 93                 else if(isUpOrDownFromPoint=="down"&&isUpOrDownToPoint=="down")//当起点和终点都在同一点
 95                     {
 96                        if(this.GetNextPoint(fromPoint,1,0)==toPoint)   //过河后可以往下走
 97                             return true;
 98                        if(this.GetNextPoint(fromPoint,0,1)==toPoint)   //过河后可以往右走
 99                              return true;
                        if(this.GetNextPoint(fromPoint,0,-1)==toPoint)  //过河后可以往左走
                             return true;
                     }                
             }            
             
             return false;            
         }
         //判断***車***的走法是否合理
         public bool JuFoot(Point fromPoint,Point toPoint)    
         {
             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引            
                     
             if(fromPoint==toPoint)  //如果起点和终点是同一个点,则允许放回旗子,重新先其它路
             {                
                 return true;
             }            
             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能走
             {                
                 return false;            
             }
             if(fromPoint.X==toPoint.X)   //判断是否在同一条垂直直线上
             {                
                 if(fromPoint.Y>toPoint.Y) //起点在终点下面情况
                     for(int i=-1;this.GetNextPoint(fromPoint,i,0)!=toPoint;i--)  //判断起点终点之间有无旗子
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,i,0))]==true)
                             return false;                    
                 
                 if(fromPoint.Y<toPoint.Y)//起点在终点上面情况
                     for(int i=1;this.GetNextPoint(fromPoint,i,0)!=toPoint;i++)  //判断起点终点之间有无旗子
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,i,0))]==true)
                             return false;    
                 return true;                    
             }
             if(fromPoint.Y==toPoint.Y)  //判断是否在同一条水平直线上
             {                
                 if(fromPoint.X<toPoint.X)  //起点在终点左边
                     for(int j=1;this.GetNextPoint(fromPoint,0,j)!=toPoint;j++)  //判断起点终点之间有无旗子
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,0,j))]==true)
                             return false;                                        
                 
                 if(fromPoint.X>toPoint.X)  //起点在终点右边
                     for(int j=-1;this.GetNextPoint(fromPoint,0,j)!=toPoint;j--)  //判断起点终点之间有无旗子
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,0,j))]==true)
                             return false;    
                 return true;
             }            
             
             return false;            
         }
         //判断***炮***的走法是否合理
         public bool CannonFoot(Point fromPoint,Point toPoint) 
         {
             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引            
                     
             if(fromPoint==toPoint)  //当起点和终点都在同一点,则允许放回旗子,重新先其它路
             {                
                 return true;
             }            
             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能落旗
             {                
                 return false;            
             }
             if(fromPoint.X==toPoint.X)    //判断起点和终点在同一垂直线上情况
             {
                 int number_QiZi=0;
                 if(fromPoint.Y>toPoint.Y) //起点在终点下面情况
                 {
                     for(int i=-1;this.GetNextPoint(fromPoint,i,0)!=toPoint;i--)  //判断起点终点之间旗子数量
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,i,0))]==true)
                             number_QiZi++;
                     if(number_QiZi>1)          //如果起点和终点之间的旗子数大于1,则不能落旗
                         return false;
                     if(number_QiZi==0&&this.have[this.CountIndex(toPoint)]==false)  //起点和终点之间无旗子，在终点落旗
                         return true;
                     if(number_QiZi==1&&this.have[this.CountIndex(toPoint)]==true)  //起点和终点之间仅有一个旗
                         return true;
                 }
 
                 number_QiZi=0;
                 if(fromPoint.Y<toPoint.Y) //起点在终点下面情况
                 {
                     for(int i=1;this.GetNextPoint(fromPoint,i,0)!=toPoint;i++)  //判断起点终点之间旗子数量
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,i,0))]==true)
                             number_QiZi++;
                     if(number_QiZi>1)          //如果起点和终点之间的旗子数大于1,则不能落旗
                         return false;
                     if(number_QiZi==0&&this.have[this.CountIndex(toPoint)]==false)       //起点和终点之间无旗子,在终点落旗
                         return true;
                     if(number_QiZi==1&&this.have[this.CountIndex(toPoint)]==true)  //起点和终点之间仅有一个旗
                         return true;                
                 }
             }
             if(fromPoint.Y==toPoint.Y)
             {
                 int number_QiZi=0;
                 if(fromPoint.X>toPoint.X) //起点在终点右边情况
                 {
                     for(int j=-1;this.GetNextPoint(fromPoint,0,j)!=toPoint;j--)  //判断起点终点之间旗子数量
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,0,j))]==true)
                             number_QiZi++;
                     if(number_QiZi>1)          //如果起点和终点之间的旗子数大于1,则不能落旗
                         return false;
                     if(number_QiZi==0&&this.have[this.CountIndex(toPoint)]==false)  //起点和终点之间无旗子在终点落旗
                         return true;
                     if(number_QiZi==1&&this.have[this.CountIndex(toPoint)]==true)  //起点和终点之间仅有一个旗
                         return true;
                 }
 
                 number_QiZi=0;
                 if(fromPoint.X<toPoint.X) //起点在终点左边情况
                 {
                     for(int j=1;this.GetNextPoint(fromPoint,0,j)!=toPoint;j++)  //判断起点终点之间旗子数量
                         if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,0,j))]==true)
                             number_QiZi++;
                     if(number_QiZi>1)          //如果起点和终点之间的旗子数大于1,则不能落旗
                         return false;
                     if(number_QiZi==0&&this.have[this.CountIndex(toPoint)]==false)       //起点和终点之间无旗子,在终点落旗
                         return true;
                     if(number_QiZi==1&&this.have[this.CountIndex(toPoint)]==true)  //起点和终点之间仅有一个旗
                         return true;                
                 }
             }                
             return false;            
         }
         //判断***象***的走法是否合理
         public bool ElephantFoot(Point fromPoint,Point toPoint)
         {
             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引            
                     
             if(fromPoint==toPoint)  //如果起点和终点是同一个点,则允许放回旗子,重新先其它路
             {                
                 return true;
             }            
             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能落旗
             {                
                 return false;            
             }
             if(this.IsUpOrDown(fromPoint)!=this.IsUpOrDown(toPoint))  //如果起点和终点所在边不相同(如一个在河上,一个在河下),则不能落旗(即各边的象不能过河)
                 return false;
             
             double twoPoint_Right_Distance=Math.Sqrt((width+width)*(width+width)+(width+width)*(width+width));
             double twoPoint_True_Distance=Math.Sqrt((fromPoint.X-toPoint.X)*(fromPoint.X-toPoint.X)+(fromPoint.Y-toPoint.Y)*(fromPoint.Y-toPoint.Y));
             
             //判断象的四种走法
             if(this.GetNextPoint(fromPoint,2,2)==toPoint)  //当象向右下方跳时情况("右下田")
                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,1,1))]==false)   //起点右下一个点上没有旗子,也就是不 "塞象" 时可以往上走旗
                 {                    
                     if(twoPoint_True_Distance<=twoPoint_Right_Distance)
                         return true;
                 }
             if(this.GetNextPoint(fromPoint,2,-2)==toPoint)  //当象向左下方跳时情况("左下田")
                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,1,-1))]==false)   //起点左下一个点上没有旗子,也就是不 "塞象" 时可以往上走旗
                 {                    
                     if(twoPoint_True_Distance<=twoPoint_Right_Distance)
                         return true;
                 }
             if(this.GetNextPoint(fromPoint,-2,2)==toPoint)  //当象向右上方跳时情况("右上田")
                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,-1,1))]==false)   //起点右上一个点上没有旗子,也就是不 "塞象" 时可以往上走旗
                 {                    
                     if(twoPoint_True_Distance<=twoPoint_Right_Distance)
                         return true;
                 }
             if(this.GetNextPoint(fromPoint,-2,-2)==toPoint)  //当象向左上方跳时情况("左上田")
                 if(this.have[this.CountIndex(this.GetNextPoint(fromPoint,-1,-1))]==false)   //起点左上一个点上没有旗子,也就是不"塞象" 时可以往上走旗
                 {                    
                     if(twoPoint_True_Distance<=twoPoint_Right_Distance)
                         return true;
                 }        
             
             return false;            
         }
         //判断***士***的走法是否合理
         public bool ScholarFoot(Point fromPoint,Point toPoint) 
         {  
             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引            
                     
             if(fromPoint==toPoint)  //如果起点和终点是同一个点,则允许放回旗子,重新先其它路
             {                
                 return true;
             }            
             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能落旗
             {                
                 return false;            
             }
             
             int index=this.CountIndex(toPoint);
             if(index!=3&&index!=5&&index!=13&&index!=21&&index!=23&&index!=66)
                 if(index!=68&&index!=76&&index!=84&&index!=86)
                     return false;      //控制士的活动范围
 
             //判断士的四种走法
             if(this.GetNextPoint(fromPoint,-1,-1)==toPoint) //士可以往左上方点移动
                 return true;        
             if(this.GetNextPoint(fromPoint,1,-1)==toPoint)  //士可以往左下方点移动
                 return true;    
             if(this.GetNextPoint(fromPoint,-1,+1)==toPoint) //士可以往右上方点移动
                 return true;    
             if(this.GetNextPoint(fromPoint,1,1)==toPoint)  //士可以往右下方点移动
                 return true;
     
             return false;            
         }
         //判断***将/帅***的走法是否合理
         public bool AgaFoot(Point fromPoint,Point toPoint)
         {
             int fromIndex=this.CountIndex(fromPoint);   //起点信息的一维数组的索引
             int toIndex=this.CountIndex(toPoint);       //终点信息的一维数组的索引            
                     
             if(GenEatGen)  //如果将与帅相望(之间没有旗子),这时老将允许直接跳河吃掉对方老将
                 if((this.whichPicture[fromIndex]==4&&this.whichPicture[toIndex]==27)||(this.whichPicture[fromIndex]==27&&this.whichPicture[toIndex]==4))
                     return true;            
             
             if(fromPoint==toPoint)  //如果起点和终点是同一个点,则允许放回旗子,重新先其它路
             {                
                 return true;
             }            
             if(who[fromIndex].Equals(who[toIndex]))  //如果起点和终点是同一边的旗子,则不能落旗
             {                
                 return false;            
             }
 
             int index=this.CountIndex(toPoint);
             if(index!=3&&index!=4&&index!=5&&index!=12&&index!=13&&index!=14&&index!=21&&index!=22&&index!=23)
                 if(index!=66&&index!=67&&index!=68&&index!=75&&index!=76&&index!=77&&index!=84&&index!=85&&index!=86)
                     return false;        //控制将帅的活动范围
             
             //判断 将/帅 的四种走法
             if(this.GetNextPoint(fromPoint,0,-1)==toPoint)  //将/帅可以往左方一点走
                 return true;        
             if(this.GetNextPoint(fromPoint,0,1)==toPoint)   //将/帅可以往右方一点走
                 return true;    
             if(this.GetNextPoint(fromPoint,-1,0)==toPoint)  //将/帅可以往上方一点走
                 return true;    
             if(this.GetNextPoint(fromPoint,1,0)==toPoint)    //将/帅可以往下方一点走
                 return true;            
             
             return false;            
         }
         public bool AcceptJudge(Point fromPoint,Point toPoint,bool GenEatGen)
         {            
             this.GenEatGen=GenEatGen;
             int index=this.CountIndex(fromPoint);            
             switch(this.str[index])
             {
                 case "黑马":
                 case "红马":  return HorseFoot(fromPoint,toPoint); 
                 case "黑兵":
                 case "红卒":  return ObiitFoot(fromPoint,toPoint);
                 case "黑車":
                 case "红車":  return JuFoot(fromPoint,toPoint);
                 case "黑炮":
                 case "红炮":  return CannonFoot(fromPoint,toPoint);
                 case "黑象":
                 case "红象":  return ElephantFoot(fromPoint,toPoint);
                 case "黑士":
                 case "红士":  return ScholarFoot(fromPoint,toPoint);
                 case "黑将":
                 case "红帅":  return AgaFoot(fromPoint,toPoint);                
             }            
             MessageBox.Show("没法确定您拿的是什么旗子,因此,不知道其步伐规则");
             return false;
         }
         
         public Point GetNextPoint(Point point,int x,int y)   //得到移动的点
         {
             int index=this.CountIndex(point);                        
             index=index+(x*9);
             index=index+y;            
372             if(index>=0&&index<90)
                 return this.CountPoint(index);
             return new Point(-1,-1);
         }
         public int ChangeQiZi(Point fromPoint,Point toPoint) 
               // index表示当前活动的pictureBox;  
               // fromPoint表示pictureBox起点;  toPoint表示pictureBox的位置点
         {
             int fromIndex=this.CountIndex(fromPoint);  //起点对应一维数组的索引
             int toIndex=this.CountIndex(toPoint);      //终点对应一维数组的索引           
 
             if(fromPoint==toPoint)
             {                    
                 return 0;        //起点和终点是同一个点,不修改旗盘参数                
             }            
             if(!this.have[toIndex])
             {                
                 //将旗盘起点对应的参数移到第二个点
                 this.have[toIndex]=this.have[fromIndex];
                 this.who[toIndex]=this.who[fromIndex].ToString();
                 this.str[toIndex]=this.str[fromIndex].ToString();
                 this.whichPicture[toIndex]=this.whichPicture[fromIndex];
                                 
                 //将旗盘起点对应的参数初始化s(即将旗子移动之前位置置为空点)
                 this.have[fromIndex]=false;
397                 this.who[fromIndex]="";
398                 this.str[fromIndex]="";
399                 this.whichPicture[fromIndex]=-1;        
             
                 return 1;
             }
             if(this.have[toIndex])
             {            
                 //红方旗子被吃一个
                 if(this.who[toIndex]=="red")  
                     rednum--;           
 
                 //黑方旗子被吃一个
                 if(this.who[toIndex]=="black")
                     blacknum--;
 
                 //将旗盘起点对应的参数移到第二个点
                 this.have[toIndex]=this.have[fromIndex];
                 this.who[toIndex]=this.who[fromIndex].ToString();
                 this.str[toIndex]=this.str[fromIndex].ToString();
                 this.whichPicture[toIndex]=this.whichPicture[fromIndex];
                                 
                 //将旗盘起点对应的参数初始化s(即将旗子移动之前位置置为空点)
                 this.have[fromIndex]=false;
                 this.who[fromIndex]="";
                 this.str[fromIndex]="";
                 this.whichPicture[fromIndex]=-1;            
                 
                 return 2;               
             }
             return -1;            
 }}