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