C#中国象棋代码-棋子移动类

1.棋子基类

抽象类,是所有棋子的基类, 注意几个重要的方法:如CanMoveTo移动算法及MoveTo移动棋子。

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using www.vjsdn.com.ChineseChess.Library;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 棋子类 
    /// </summary> 
    public  abstract  class Chess
   {
       protected ChessColor _color;
       protected ChessPoint _currentPoint;
       protected ChessBoard _chessboard;
      
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Chess(ChessColor color, ChessPoint tragpoint, ChessBoard board)
      {
          this._color = color;
          this._currentPoint = tragpoint;
          this._chessboard = board;
      }
      
       /// <summary> 
       /// 棋子颜色 
       /// </summary> 
       public ChessColor Color
      {
          get {  return _color; }
          set { _color = value; }
      }
      
       /// <summary> 
       /// 当前坐标 
       /// </summary> 
       public ChessPoint CurrentPoint
      {
          get {  return _currentPoint; }
          set { _currentPoint = value; }
      }
      
       /// <summary> 
       /// 棋盘 
       /// </summary> 
       public ChessBoard Chessboard
      {
          get {  return _chessboard; }
          set { _chessboard = value; }
      }
      
       /// <summary> 
       /// 棋子图片:抽象的属性 
       /// </summary> 
       public  abstract Image ChessImage {  get;}
      
       /// <summary> 
       /// 是否能够移动 
       /// </summary> 
       protected  abstract  bool CanMoveTo(ChessPoint p);
      
       /// <summary> 
       /// 移动方法 
       /// </summary> 
       public  void MoveTo(ChessPoint targetPoint)
      {
          //目标棋子和当前棋子颜色不能一致 
         Chess targetChess = _chessboard[targetPoint];
         
          if (targetChess !=  null && targetChess.Color ==  this._color)  return;
         
          //是否满足规则 
          if (!CanMoveTo(targetPoint))  return;
         
          //吃掉对方老王 
          if (_chessboard[targetPoint]  is King)
          throw  new GameLoseException( this.Color == ChessColor.Red ? "红方胜" : "黑方胜");
         
          //移动 
         _chessboard[_currentPoint] =  null;  //吃掉棋子或移动棋子 
         _chessboard[targetPoint] =  this;
         
          this._currentPoint = targetPoint;
      }
      
       /// <summary> 
       /// 获取两点之间的棋子数 
       /// </summary> 
       public  int GetChessCount(ChessPoint start, ChessPoint end)
      {
          //如果Y相同 
          if (start.Y == end.Y)
         {
             //获取最大X和最小X值 
             int min = Math.Min(start.X, end.X);
             int max = Math.Max(start.X, end.X);
            
             //棋子计数器 
             int count = 0;
             for ( int i = min + 1; i < max; i++)
            {
                if (_chessboard[i, start.Y] !=  null)
               count++;
            }
             return count;
         }
          else
         {
             int min = Math.Min(start.Y, end.Y);
             int max = Math.Max(start.Y, end.Y);
            
             int count = 0;
             for ( int i = min + 1; i < max; i++)
            {
                if (_chessboard[start.X, i] !=  null)
               count++;
            }
             return count;
         }
      }
      
   }
}

2.车(Rooks) 

学习车移动算法CanMoveTo. 移动规则: 1.两点在一条直线上 ,2.中间不能有棋子

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 车 
    /// </summary> 
    public  class Rooks : Chess
   {
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Rooks(ChessColor color, ChessPoint tragPoint, ChessBoard board)
      :  base(color, tragPoint, board)
      {
          // 
      }
      
       /// <summary> 
       /// 重写图片的属性 
       /// </summary> 
       public  override Image ChessImage
      {
          get
         {
             //红车 
             if (_color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 1);
             else //黑车
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 8);
         }
      }
      
       /// <summary> 
       /// 棋子是否能够移动到目标点 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint targetPoint)
      {
          //两点在一条直线上 
          if (targetPoint.X != _currentPoint.X && targetPoint.Y != _currentPoint.Y)
          return  false;
         
          //中间不能有棋子 
          if (GetChessCount(_currentPoint, targetPoint) > 0)
          return  false;
         
          return  true;
      }
      
   }
}

3.马(Knights) 

学习马移动算法
移动规则:蹩脚算法,直线一侧不能有棋子

using System;
using System.Collections.Generic;
using System.Text;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 马 
    /// </summary> 
    public  class Knights : Chess
   {
      
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Knights(ChessColor color, ChessPoint tragPoint, ChessBoard board)
      :  base(color, tragPoint, board)
      {
          // 
      }
      
       /// <summary> 
       /// 象棋图片 
       /// </summary> 
       public  override System.Drawing.Image ChessImage
      {
          get
         {
             //红马 
             if ( this._color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 2);
             //黑马 
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 9);
         }
      }
      
       /// <summary> 
       /// 马移动算法 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint p)
      {
          //蹩脚算法 
          //横向移动 
          if (Math.Abs(_currentPoint.X - p.X) == 2 && Math.Abs(_currentPoint.Y - p.Y) == 1)
         {
             if (_chessboard[(_currentPoint.X + p.X) / 2, _currentPoint.Y] ==  null)
             return  true;
         }
          if (Math.Abs(_currentPoint.X - p.X) == 1 && Math.Abs(_currentPoint.Y - p.Y) == 2)
         {
             if (_chessboard[_currentPoint.X, (_currentPoint.Y + p.Y) / 2] ==  null)
             return  true;
         }
          return  false;
      }
   }
}

4.象/相(Elephants) 学习移动算法

移动规则:1.田子中间不能有棋子 2.不能过河

using System;
using System.Collections.Generic;
using System.Text;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 象--相 
    /// </summary> 
    public  class Elephants : Chess
   {
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Elephants(ChessColor color, ChessPoint p, ChessBoard board)
      :  base(color, p, board)
      {
          // 
      }
      
       /// <summary> 
       /// 象棋图片 
       /// </summary> 
       public  override System.Drawing.Image ChessImage
      {
          get
         {
             //红相 
             if ( this._color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 6);
             //黑象 
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 13);
         }
      }
      
       /// <summary> 
       /// 象移动算法 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint p)
      {
          //绝对值法 
          if (Math.Abs(_currentPoint.X - p.X) != 2 || Math.Abs(_currentPoint.Y - p.Y) != 2)
          return  false;
         
          //中间不能有棋子 
          if (_chessboard[(_currentPoint.X + p.X) / 2, (_currentPoint.Y + p.Y) / 2] !=  null)
          return  false;
         
          //越界算法 
          if (_currentPoint.Y <= 4 && p.Y > 4)  return  false;
          if (_currentPoint.Y >= 5 && p.Y < 5)  return  false;
         
          return  true;
      }
   }
}

5.士/仕(Mandarins)

移动规则:1.“士”不能出城 2.“士”每次只能走一步且只能是斜线

using System;
using System.Collections.Generic;
using System.Text;
using www.vjsdn.com.ChineseChess.Library;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 士 
    /// </summary> 
    public  class Mandarins : Chess
   {
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Mandarins(ChessColor color, ChessPoint tragPoint, ChessBoard board)
      :  base(color, tragPoint, board)
      {
          // 
      }
      
       /// <summary> 
       /// 象棋图片 
       /// </summary> 
       public  override System.Drawing.Image ChessImage
      {
          get
         {
             //红士 
             if ( this._color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 5);
             //黑士 
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 12);
         }
      }
      
       /// <summary> 
       /// 兵移动算法 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint tragPoint)
      {
          //“士”不能出城 
          if (!((tragPoint.X >= 3 && tragPoint.X <= 5) && (tragPoint.Y <= 2 || tragPoint.Y >= 7)))
          return  false;
         
          //“士”每次只能走一步且只能是斜线 
          if (!(Math.Abs(tragPoint.X -  this._currentPoint.X) == 1 && Math.Abs(tragPoint.Y -  this._currentPoint.Y) == 1))
          return  false;
         
          return  true;
      }
   }
}

6.将/帅(King)

移动规则: 1.“将”不能出城 2.“将”每次只能走一步 

using System;
using System.Collections.Generic;
using System.Text;
using www.vjsdn.com.ChineseChess.Library;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 将/帅 
    /// </summary> 
    public  class King : Chess
   {
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public King(ChessColor color, ChessPoint tragPoint, ChessBoard board)
      :  base(color, tragPoint, board)
      {
          // 
      }
      
       /// <summary> 
       /// 象棋图片 
       /// </summary> 
       public  override System.Drawing.Image ChessImage
      {
          get
         {
             //红将 
             if ( this._color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 4);
             //黑将 
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 11);
         }
      }
      
       /// <summary> 
       /// 将移动算法 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint tragPoint)
      {
          //“将”不能出城 
          if (!((tragPoint.X >= 3 && tragPoint.X <= 5) && (tragPoint.Y <= 2 || tragPoint.Y >= 7)))
          return  false;
         
          //“将”每次只能走一步 
          if ((Math.Abs(tragPoint.X -  this._currentPoint.X) + Math.Abs(tragPoint.Y -  this._currentPoint.Y)) != 1)
          return  false;
         
          return  true;
      }
      
   }
}

7.炮/砲(Connons)

移动规则: 1.两点在一条直线上 2.目标点不为空,中间只能由一个棋子  3.目标点为空,中间不能有棋子 

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 炮 
    /// </summary> 
    public  class Cannons : Chess
   {
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Cannons(ChessColor color, ChessPoint tragPoint, ChessBoard board)
      :  base(color, tragPoint, board)
      {
          // 
      }
      
       /// <summary> 
       /// 重写图片的属性 
       /// </summary> 
       public  override Image ChessImage
      {
          get
         {
             //红炮 
             if (_color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 3);
             //黑炮 
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 10);
         }
      }
      
       /// <summary> 
       /// 棋子是否能够移动到目标点 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint targPoint)
      {
          //两点在一条直线上 
          if (targPoint.X != _currentPoint.X && targPoint.Y != _currentPoint.Y)
          return  false;
         
          //目标点不为空,中间只能由一个棋子 
          if (_chessboard[targPoint] !=  null && GetChessCount(_currentPoint, targPoint) != 1)
          return  false;
         
          //目标点为空,中间不能有棋子 
          if (_chessboard[targPoint] ==  null && GetChessCount(_currentPoint, targPoint) > 0)
          return  false;
         
          return  true;
         
      }
      
   }
}

8.兵/卒 (Pawns)

移动规则:1.兵不能往后走 2.兵一步一步走 3.过河前只能向前走

using System;
using System.Collections.Generic;
using System.Text;
using www.vjsdn.com.ChineseChess.Library;

namespace www.vjsdn.com.ChineseChess.Library
{
    /// <summary> 
    /// 兵 
    /// </summary> 
    public  class Pawns : Chess
   {
       //是否过河 
       private  bool _isRiverd =  false;
       private  int _step = 0;  //记录步数 
      
       /// <summary> 
       /// 构造函数 
       /// </summary> 
       public Pawns(ChessColor color, ChessPoint tragPoint, ChessBoard board)
      :  base(color, tragPoint, board)
      {
          if (_currentPoint.Y > 4)
         _step = -1;
          else
         _step = 1;
      }
      
       /// <summary> 
       /// 象棋图片 
       /// </summary> 
       public  override System.Drawing.Image ChessImage
      {
          get
         {
             //红兵 
             if ( this._color == ChessColor.Red)
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 7);
             //黑卒 
             return ImageHelper.GetImageByAverageIndex(ChineseChess.Res.Properties.Resources.xchess, 14, 14);
         }
      }
      
       /// <summary> 
       /// 兵移动算法 
       /// </summary> 
       protected  override  bool CanMoveTo(ChessPoint p)
      {
          //兵不能往后走 
          if (p.Y - _currentPoint.Y == -_step)
          return  false;
         
          //兵一步一步走 
          if (Math.Abs(_currentPoint.X - p.X) + Math.Abs(_currentPoint.Y - p.Y) != 1)
          return  false;
         
          //过河 
          if (!_isRiverd)
         {
             if (_currentPoint.Y == 4 && p.Y == 5) _isRiverd =  true;
             if (_currentPoint.Y == 5 && p.Y == 4) _isRiverd =  true;
         }
         
          //过河前只能向前走 
          if (!_isRiverd)
         {
             if (p.Y - _currentPoint.Y != _step)
             return  false;
         }
         
          return  true;
      }
   }
}