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;
}
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
