///// <summary>
///// Trả về độ di động của phe ta trừ phe địch
///// </summary>
//static int Mobility(int[,] BoardState)
//{
// int intSide = 0;
// if (Myside == ChessSide.White)
// {
// intSide = 2;
// }
// else
// {
// intSide = 1;
// }
// int intMobility = 0;
// for (int y = 1; y <= 8; y++)
// for (int x = 1; x <= 8; x++)
// if (BoardState[x, y] > 0)
// {
// int side = BoardState[x, y] % 10;
// int intType = BoardState[x, y] / 10;
// if (side == intSide)
// {
// intMobility += FindAllLegalMove(BoardState, new Point(x, y), (ChessPieceType)intType).Count;
// }
// else
// {
// intMobility -= FindAllLegalMove(BoardState, new Point(x, y), (ChessPieceType)intType).Count;
// }
// }
// return intMobility;
//}
public static ArrayList FindAllLegalMove(int[,] arrState, Point CurPos, ChessPieceType eType)
{
ArrayList arrPossibleMove = FindAllPossibleMove(arrState, CurPos, eType);
if (arrPossibleMove.Count == 0)
{
return(arrPossibleMove);
}
ArrayList arrLegalMove = new ArrayList();
//Những nước đi làm cho quân Vua phe mình bị chiếu được xem là không hợp lệ
int[,] arrNewState = new int[10, 10];
Array.Copy(arrState, arrNewState, arrState.Length);
ChessSide eSide = (ChessSide)(arrState[CurPos.X, CurPos.Y] % 10);
foreach (Point p in arrPossibleMove)
{
int tmp = arrNewState[p.X, p.Y]; //Quân cờ tại vị trí mới
arrNewState[p.X, p.Y] = (int)eType * 10 + (int)eSide; //Thay quân cờ tại vị trí mới
arrNewState[CurPos.X, CurPos.Y] = 0; //Xóa quân cờ tại vị trí cũ
if (clsKing.IsChecked(arrNewState, eSide) == false)
{
arrLegalMove.Add(p);
}
arrNewState[CurPos.X, CurPos.Y] = arrNewState[p.X, p.Y]; //Cho quân cờ quay lại vị trí cũ
arrNewState[p.X, p.Y] = tmp; //Trả lại quân cờ nằm ở vị trí mới
}
return(arrLegalMove);
}
/// <param name="eBoardStyle">Kiểu bàn cờ</param>
/// <param name="ePieceStyle">Kiểu quân cờ</param>
/// <param name="eOwnSide">Quân Mà Người Chơi Chọn</param>
/// <param name="eGameMode">Chế Độ Chơi</param>
/// <param name="CellSize">Kích thước ô cờ</param>
/// <param name="PieceSize">Kích thước quân cờ (Mặc định nếu =0)</param>
/// <param name="bPlaySound">Âm Thanh</param>
/// <param name="strFEN">Forsyth-Edwards Notation</param>
/// Chơi Với Người
public UcChessBoard(ChessBoardStyle eBoardStyle, ChessPieceStyle ePieceStyle, ChessSide eOwnSide, GameMode eGameMode, int CellSize, int PieceSize, bool bPlaySound, string strFEN)
{
InitializeComponent();
this.Size = new Size(CellSize * 8, CellSize * 8);
this._BlackCellBitmap = clsImageProcess.GetChessBoardBitMap(ChessSide.Black, eBoardStyle);
this._WhiteCellBitmap = clsImageProcess.GetChessBoardBitMap(ChessSide.White, eBoardStyle);
this._CellSize = CellSize;
this._PieceSize = PieceSize;
this._PieceStyle = ePieceStyle;
this._BoardStyle = eBoardStyle;
this._PlaySound = bPlaySound;
this._OwnSide = eOwnSide;
this._GameMode = eGameMode;
CreateChessBoard(); //Tạo các ô cờ
kingsideCastling = true; //Nhập thành gần, quân đen
queensideCastling = true; //Nhập thành xa, quân đen
KINGsideCastling = true; //Nhập thành gần, quân trắng
QUEENsideCastling = true; //Nhập thành xa, quân trắng
_EnPassantPoint = new Point();
clsFEN.SetFEN(this, strFEN);
AddChessPiece(ePieceStyle, this._BoardState);
}
public static int GetPositionValue(Point pos, ChessSide eSide, bool IsEndGame)
{
if (IsEndGame == false)
{
if (eSide == ChessSide.Black)
{
return(KingTable[pos.Y, pos.X]);
}
else
{
return(KingTable[9 - pos.Y, 9 - pos.X]);
}
}
else
{
if (eSide == ChessSide.Black)
{
return(KingTableEndGame[pos.Y, pos.X]);
}
else
{
return(KingTableEndGame[9 - pos.Y, 9 - pos.X]);
}
}
}
public void SetCheck(ChessSide side)
{
string message = "Check for " + side.ToString();
Debug.Log(message);
MainMenu.Singleton.AppendConsoleText(message);
}
public static int GetPositionValue(Vector2 pos, ChessSide eSide, bool IsEndGame)
{
if (IsEndGame == false)
{
if (eSide == ChessSide.Black)
{
return(KingTable[(int)(int)pos.y, (int)(int)pos.x]);
}
else
{
return(KingTable[9 - (int)(int)pos.y, 9 - (int)(int)pos.x]);
}
}
else
{
if (eSide == ChessSide.Black)
{
return(KingTableEndGame[(int)pos.y, (int)pos.x]);
}
else
{
return(KingTableEndGame[9 - (int)pos.y, 9 - (int)pos.x]);
}
}
}
public ComputerPlayer(ChessSide side, byte skill, IChessUCIEngine chessUCIEngine) : base(PlayerType.computer, side)
{
this.skill = skill;
this.chessUCIEngine = chessUCIEngine;
this.chessUCIEngine.StartEngine();
this.chessUCIEngine.SetSkill(skill);
}
private void btnBegin_Click(object sender, EventArgs e)
{
if (cboGameMode.SelectedIndex == 0)
{
eGameMode = GameMode.VsComputer;
}
else
{
eGameMode = GameMode.VsHuman;
}
if (radWhite.Checked)
{
eOwnSide = ChessSide.White;
}
else
{
eOwnSide = ChessSide.Black;
}
if (radEasy.Checked)
{
eDifficulty = GameDifficulty.Easy;
}
else if (radNormal.Checked)
{
eDifficulty = GameDifficulty.Normal;
}
else
{
eDifficulty = GameDifficulty.Hard;
}
TimeLimit = Convert.ToInt16(iTimeLimit.Value);
TimeBonus = Convert.ToInt16(iTImeBonus.Value);
}
public override void MoveFigure(Vector2Int prev_pos, Vector2Int new_pos, ChessSide side)
{
foreach (var item in boardItemsMono)
{
item.StopAnimation();
}
GetBoardItemMono(prev_pos).IsSelected = false;
var figure_path = PathFinder.GetPath(
GetChessItemMono(prev_pos).props.type,
prev_pos.ToBoardPosition(),
new_pos.ToBoardPosition(),
new BoardPosition(iFigureOnBoard.BoardSizeX, iFigureOnBoard.BoardSizeY),
IsJump(new_pos));
GetChessItemMono(prev_pos).MoveFigureToPosition(figure_path.ToVector2List());
currentProps = chessItemProtertiesFactory.CreateNullChessItemProperties();
PrevProps = chessItemProtertiesFactory.CreateNullChessItemProperties();
mm.SetMoveTextValue(prev_pos, new_pos);
}
/// <summary>
/// Trả về độ di động của Side cần kiểm tra
/// </summary>
static int Mobility(ChessSide eSide, int[,] BoardState)
{
int intSide = 0;
if (eSide == ChessSide.White)
{
intSide = 2;
}
else
{
intSide = 1;
}
int intMobility = 0;
for (int y = 1; y <= 8; y++)
{
for (int x = 1; x <= 8; x++)
{
if (BoardState[x, y] > 0)
{
int side = BoardState[x, y] % 10;
if (side == intSide)
{
int intType = BoardState[x, y] / 10;
intMobility += FindAllLegalMove(BoardState, new Point(x, y), (ChessPieceType)intType).Count;
}
}
}
}
return(intMobility);
}
public ChessItemProperties(Vector2Int pos, byte type, ChessSide side, bool isNullObject = false)
{
this.pos = pos;
this.type = type;
this.side = side;
this.isNullObject = isNullObject;
}
public ChessItemProperties(Vector2Int pos)
{
this.pos = pos;
this.type = (byte)ClassicChessItemType.pawn;
this.side = ChessSide.white;
this.isNullObject = true;
}
private void btnNewGame_Click(object sender, EventArgs e)
{
frmSelectGame frm = new frmSelectGame();
if (frm.ShowDialog() == DialogResult.OK)
{
ChessSide eOwnSide = frm.eOwnSide;
GameMode eGameMode = frm.eGameMode;
GameDifficulty eDifficulty = frm.eDifficulty;
string strFen = clsFEN.DefaultFENstring;
this.TimeLimit = frm.TimeLimit;
this.TimeBonus = frm.TimeBonus;
if (eGameMode == GameMode.VsComputer)
{
CreateChessBoard(eOwnSide, eGameMode, eDifficulty, strFen);
}
else
{
CreateChessBoard(eOwnSide, eGameMode, strFen);
}
frmMessageBox.ShowMessage = true;
PlayMusic(soundNewGame);
}
frm.Dispose();
}
IEnumerator ComputerThinking()
{
string strFen = clsFEN.GetFENWithoutMoveNumber(this);
MyMove = clsChessEngine.ReadFromBook(strFen);
if (MyMove == null)
{
MyMove = new clsMove(new Vector2(), new Vector2());
arrMove = clsChessEngine.GenerateMove(this._BoardState, this.arrFEN, ChessSide.Black, ref MyMove, Difficult);
if (Difficult == GameDifficulty.Hard)
{
clsChessEngine.WriteToBook(strFen, MyMove);
}
}
else
{
ChessPieceType eType = (ChessPieceType)(this._BoardState[(int)MyMove.CurPos.x, (int)MyMove.CurPos.y] / 10);
arrMove = clsChessEngine.FindAllLegalMove(this._BoardState, MyMove.CurPos, eType);
}
LastMove = MyMove;
yield return(null);
AiMove();
Debug.LogError(MyMove.CurPos + " " + MyMove.NewPos);
isThinking = false;
isWhite = ChessSide.White;
arrFEN.Add(clsFEN.GetPiecePlacementString(this._BoardState));
}
protected virtual void MoveFigure(ChessSide side)
{
MatchView_ControllerAPI.MoveFigure(
ChessMatchCurrentState.PreviousSelectedPosition.ToVector2Int(),
ChessMatchCurrentState.CurrentSelectedPosition.ToVector2Int(),
side);
}
public override string getNotation(ChessSide side,
ChessPiece[,]
positions, int sr,
int sf, int dr,
int df,
PromotionType
promotion_type)
{
string str;
if (sf == df)
{
str = "" + (char) ('a' + df) + (dr +
1);
}
else
{
str = "" + (char) ('a' + sf);
if (positions[dr, df] != null)
str += 'x';
str += "" + (char) ('a' + df) +
(dr + 1);
}
if (dr == 7 || dr == 0)
{
/* No need to verify for specific colors
* only whites can reach 7 and blacks can reach 0
*/
str += ChessPiece.
getPromotionString
(promotion_type);
}
return str;
}
public virtual void MoveFigure(Vector2Int prev_pos, Vector2Int new_pos, ChessSide side)
{
foreach (var item in boardItemsMono)
{
item.StopAnimation();
}
GetBoardItemMono(prev_pos).IsSelected = false;
GetChessItemMono(prev_pos).MoveFigureToPosition(new Vector2Int[1] {
new_pos
});
//Check for pawn becomes queen
var ch_m = GetChessItemMono(new_pos);
if (!ch_m.props.isNullObject && ch_m.props.type == (byte)ClassicChessItemType.pawn)
{
if (ch_m.props.side == ChessSide.white && ch_m.props.pos.y == boardSizeY - 1 ||
(ch_m.props.side == ChessSide.black && ch_m.props.pos.y == 0))
{
ch_m.SetChessItem((byte)ClassicChessItemType.queen, ch_m.props.side);
}
}
currentProps = chessItemProtertiesFactory.CreateNullChessItemProperties();
PrevProps = chessItemProtertiesFactory.CreateNullChessItemProperties();
mm.SetMoveTextValue(prev_pos, new_pos);
}
public void SetChessItem(byte type, ChessSide side)
{
props.side = side;
props.type = type;
if (new byte[] {
(byte)ClassicChessItemType.pawn,
(byte)LosAlamosChessItemType.pawn,
(byte)ChaturangaChessItemType.pawn,
(byte)CircledChessItemType.pawn_left,
(byte)CircledChessItemType.pawn_right
}.Contains(type))
{
sprRend.sprite = MainMenu.Singleton.GetCurrentBoardPrefabs().chessPackList[(byte)side].pawn.GetComponent <SpriteRenderer>().sprite;
}
else if (new byte[] {
(byte)ClassicChessItemType.rook,
(byte)LosAlamosChessItemType.rook,
(byte)ChaturangaChessItemType.rook,
(byte)CircledChessItemType.rook
}.Contains(type))
{
sprRend.sprite = MainMenu.Singleton.GetCurrentBoardPrefabs().chessPackList[(byte)side].rook.GetComponent <SpriteRenderer>().sprite;
}
else if (new byte[] {
(byte)ClassicChessItemType.knight,
(byte)LosAlamosChessItemType.knight,
(byte)ChaturangaChessItemType.knight,
(byte)CircledChessItemType.knight
}.Contains(type))
{
sprRend.sprite = MainMenu.Singleton.GetCurrentBoardPrefabs().chessPackList[(byte)side].knight.GetComponent <SpriteRenderer>().sprite;
}
else if (new byte[] {
(byte)ClassicChessItemType.bishop,
(byte)CircledChessItemType.bishop
}.Contains(type))
{
sprRend.sprite = MainMenu.Singleton.GetCurrentBoardPrefabs().chessPackList[(byte)side].bishop.GetComponent <SpriteRenderer>().sprite;
}
else if (new byte[] {
(byte)ClassicChessItemType.queen,
(byte)LosAlamosChessItemType.queen,
(byte)ChaturangaChessItemType.queen,
(byte)CircledChessItemType.queen
}.Contains(type))
{
sprRend.sprite = MainMenu.Singleton.GetCurrentBoardPrefabs().chessPackList[(byte)side].queen.GetComponent <SpriteRenderer>().sprite;
}
else if (new byte[] {
(byte)ClassicChessItemType.king,
(byte)LosAlamosChessItemType.king,
(byte)ChaturangaChessItemType.king,
(byte)CircledChessItemType.king
}.Contains(type))
{
sprRend.sprite = MainMenu.Singleton.GetCurrentBoardPrefabs().chessPackList[(byte)side].king.GetComponent <SpriteRenderer>().sprite;
}
}
public void SetMate(ChessSide side)
{
string message = "Mate for " + side.ToString();
Debug.Log(message);
MainMenu.Singleton.AppendConsoleText(message);
isMate = true;
}
public ChessItemModelShort(ChessSide Side, BoardPosition Pos, byte Type, int Steps, bool isNullObject)
{
this.Side = Side;
this.Pos = Pos;
this.Type = Type;
this.Steps = Steps;
this.IsNullObject = isNullObject;
}
public ChessItemModelBase(ChessSide side, byte type, BoardPosition pos, int steps, bool isNullObject = false)
{
Side = side;
Type = type;
Pos = pos;
Steps = steps;
IsNullObject = isNullObject;
}
public clsSavedGame(GameMode eGameMode, GameDifficulty eDifficulty, ChessSide eOwnSide, string strFEN, string strMoveList)
{
this._GameMode = eGameMode;
this._Diff = eDifficulty;
this._OwnSide = eOwnSide;
this._FEN = strFEN;
this._MoveList = strMoveList;
}
public King(ColorType color, int rank, int file,
ChessSide myside,
ChessSide oppside)
: base(PieceType.KING,
color, rank,
file, myside,
oppside)
{
}
public Rook(ColorType color, int rank, int file,
ChessSide myside,
ChessSide oppside)
: base(PieceType.ROOK,
color, rank,
file, myside,
oppside)
{
}
public Pawn(ColorType color, int rank, int file,
ChessSide myside,
ChessSide oppside)
: base(PieceType.PAWN,
color, rank,
file, myside,
oppside)
{
}
public UcChessCell(int PositionX, int PositionY, Bitmap BackImage, ChessSide Side, ChessBoardStyle Style)
{
InitializeComponent();
this._PositionX = PositionX;
this._PositionY = PositionY;
this._Side = Side;
this._BoardStyle = Style;
this._BackImage = BackImage;
}
public Knight(ColorType color, int rank, int file,
ChessSide myside,
ChessSide oppside)
: base(PieceType.
KNIGHT, color,
rank, file,
myside,
oppside)
{
}
public Queen(ColorType color, int rank, int file,
ChessSide myside,
ChessSide oppside)
: base(PieceType.
QUEEN, color,
rank, file,
myside,
oppside)
{
}
public override string getNotation(ChessSide side,
ChessPiece[,]
positions, int sr,
int sf, int dr,
int df,
PromotionType
promotion)
{
return "K" + (char) ('a' + df) + (dr + 1);
}
public Bishop(ColorType color, int rank, int file,
ChessSide myside,
ChessSide oppside)
: base(PieceType.
BISHOP, color,
rank, file,
myside,
oppside)
{
}
public static int GetPositionValue(Vector2 pos, ChessSide eSide)
{
if (eSide == ChessSide.White)
{
return(BishopTable [(int)pos.x, (int)pos.y]);
}
else
{
return(BishopTable[9 - (int)pos.y, 9 - (int)pos.x]);
}
}
public UcChessCell(int PositionX, int PositionY, ChessSide Side, ChessBoardStyle Style)
{
InitializeComponent();
this._PositionX = PositionX;
this._PositionY = PositionY;
this._Side = Side;
this._BoardStyle = Style;
this._BackImage = clsImageProcess.GetChessBoardBitMap(Side, Style);
this.BackImage = _BackImage;
}
public static int GetPositionValue(Vector2 pos, ChessSide eSide)
{
if (eSide == ChessSide.Black)
{
return(QueenTable [(int)pos.y, (int)pos.x]);
}
else
{
return(QueenTable[9 - (int)pos.y, 9 - (int)pos.x]);
}
}
public static int GetPositionValue(Point pos, ChessSide eSide)
{
if (eSide == ChessSide.Black)
{
return(QueenTable [pos.Y, pos.X]);
}
else
{
return(QueenTable[9 - pos.Y, 9 - pos.X]);
}
}
//Hàm kiểm tra quân vua của 1 phe có đang bị chiếu hay không
public static bool IsChecked(int[,] arrState, ChessSide eSide)
{
int[,] State = new int[10, 10];
Array.Copy(arrState, State, arrState.Length); //copy mảng
Point pKingPos = FindKingPosition(State, eSide); //Tìm vị trí quân vua đang kiểm tra
int intSide = (int)eSide; //Phe của quân đang kiểm tra
for (int y = 1; y <= 8; y++)
{
for (int x = 1; x <= 8; x++)
{
if (State[x, y] > 0 && State[x, y] % 10 != intSide)//Nếu là quân khác phe
{
ArrayList arrMove = new ArrayList();
ChessPieceType eType = (ChessPieceType)(State[x, y] / 10);
if (eType == ChessPieceType.Bishop)
{
arrMove = clsBishop.FindAllPossibleMove(State, new Point(x, y));
}
if (eType == ChessPieceType.King)
{
arrMove = clsKing.FindAllPossibleMove(State, new Point(x, y));
}
if (eType == ChessPieceType.Knight)
{
arrMove = clsKnight.FindAllPossibleMove(State, new Point(x, y));
}
if (eType == ChessPieceType.Pawn)
{
arrMove = clsPawn.FindAllPossibleMove(State, new Point(x, y));
}
if (eType == ChessPieceType.Queen)
{
arrMove = clsQueen.FindAllPossibleMove(State, new Point(x, y));
}
if (eType == ChessPieceType.Rook)
{
arrMove = clsRook.FindAllPossibleMove(State, new Point(x, y));
}
foreach (Point p in arrMove)
{
if (p == pKingPos)
{
return(true);
}
}
}
}
}
return(false);
}
void PushMove(ChessSide side, string strMove)
{
if (side == ChessSide.White)
{
stkWhiteMoves.Push(strMove);
}
else
{
stkBlackMoves.Push(strMove);
}
}
public UcChessPiece(ChessSide Side, ChessPieceType Type, ChessPieceStyle Style, int intCellSize, int intPieceSize)
{
InitializeComponent();
this._Side = Side;
this._Type = Type;
this._Style = Style;
this._image = clsImageProcess.GetChessPieceBitMap(_Side, _Type, _Style);
this._CellSize = intCellSize;
this._PieceSize = intPieceSize;
this.Size = new Size(this._PieceSize, this._PieceSize);
}
protected ChessPiece(PieceType type, ColorType color,
int rank, int file,
ChessSide myside,
ChessSide oppside)
{
this.type = type;
this.myside = myside;
this.oppside = oppside;
this.color = color;
this.rank = rank;
this.file = file;
}
private int[] positions = new int[32]; //记录棋子位置
#endregion Fields
#region Constructors
public Situation(ChessSide side = ChessSide.Red)
{
Side = side;
ChessPiece piece = null;
for (int n = 0; n < 32; n++)
{
piece = BuildChessPices(n);
pieces[POSITIONS[n]] = piece;
codes[n] = piece;
positions[n] = POSITIONS[n];
}
init();
}
public FigureMove(BoardPosition from, BoardPosition to, IChessItemModel killed_item, ChessSide side)
{
from_x = from.horizontal;
from_y = from.vertical;
to_x = to.horizontal;
to_y = to.vertical;
killed_side = killed_item.Side;
killed_type = killed_item.Type;
killed_steps = (short)killed_item.Steps;
killed_x = killed_item.Pos.horizontal;
killed_y = killed_item.Pos.vertical;
killed_isnull = killed_item.IsNullObject;
this.side = side;
}
public UcChessPiece(ChessSide Side, ChessPieceType Type, ChessPieceStyle Style, int intCellSize, int intPieceSize, int PositionX, int PositionY, UcChessCell UcOnCell)
{
InitializeComponent();
this._Side = Side;
this._Type = Type;
this._Style = Style;
this._image = clsImageProcess.GetChessPieceBitMap(_Side, _Type, _Style);
this._PieceSize = intPieceSize;
this._CellSize = intCellSize;
this.Size = new Size(this._PieceSize, this._PieceSize);
this._PositionX = PositionX;
this._PositionY = PositionY;
this._ucOnCell = UcOnCell;
}
public static void GetDefaultSides(out ChessSide
white,
out ChessSide
black)
{
white = new ChessSide (ColorType.WHITE);
black = new ChessSide (ColorType.BLACK);
FillDefaultPieces (ColorType.WHITE, white,
black);
FillDefaultPieces (ColorType.BLACK, black,
white);
}
public void SwitchPlayer()
{
if (Side == ChessSide.Red)
{
Side = ChessSide.Black;
}
else
{
Side = ChessSide.Red;
}
}
public static ChessGamePlayer CreateFromFEN(string
fen)
{
PositionInfo info = new PositionInfo (fen);
string[]lines = info.position_str.Split ('/');
if (lines.Length != 8)
throw new
ChessException
(Catalog.GetString("Invalid number tokens in the FEN position"));
ChessSide whites =
new ChessSide (ColorType.WHITE);
ChessSide blacks =
new ChessSide (ColorType.BLACK);
for (int i = 0; i < lines.Length; i++)
{
string line = lines[i];
for (int j = 0; j < line.Length;
j++)
{
char ch = line[j];
if (Char.IsNumber (ch))
{
j += ch - '1'; // starting from 1 since j++ will increment 1
continue;
}
int rank = 7 - i;
int file = j;
ChessPiece piece;
GetPieceForFENChar (ch,
whites,
blacks,
rank,
file,
out
piece);
piece.addToSide ();
}
}
whites.King.CanCastle = info.WhiteCanCastle;
blacks.King.CanCastle = info.BlackCanCastle;
ChessGamePlayer game = new ChessGamePlayer ();
game.turn = info.Turn;
game.StartGame (whites, blacks);
return game;
}
public bool castle(ChessSide side, ColorType color,
CastleType castle)
{
if (!side.King.CanCastle)
{
debug (Catalog.GetString("Cant castle (") + side.King);
return false;
}
if (side.King.File !=
ChessBoardConstants.FILE_E)
{
debug (Catalog.GetString("King not available ") +
side.King);
return false;
}
int file;
if (castle == CastleType.LONG_CASTLE)
{
file = ChessBoardConstants.FILE_A;
}
else
{
file = ChessBoardConstants.FILE_H;
}
int rank;
if (color == ColorType.WHITE)
rank = 0;
else
rank = 7;
if (positions[rank, file] == null)
{
debug (Catalog.GetString("Rook not available"));
return false;
}
int i1, i2;
if (castle == CastleType.LONG_CASTLE)
{
i1 = ChessBoardConstants.FILE_B;
i2 = ChessBoardConstants.FILE_E;
}
else
{
i1 = ChessBoardConstants.FILE_F;
i2 = ChessBoardConstants.FILE_H;
}
for (int i = i1; i < i2; i++)
{
if (positions[rank, i] != null)
{ // some pieces blocking.. cannot castle
return false;
}
}
IList attackers = new ArrayList ();
ChessPiece.
getAttackers ((color ==
ColorType.
WHITE ? whites :
blacks),
(color ==
ColorType.
WHITE ? blacks :
whites), rank,
ChessBoardConstants.
FILE_E, positions, null,
attackers);
// check if king is under attack.
// cannot castle in that case
if (attackers.Count > 0)
{
return false;
}
if (castle == CastleType.LONG_CASTLE)
i1 = ChessBoardConstants.FILE_C;
for (int i = i1; i < i2; i++)
{
attackers.Clear ();
ChessPiece.
getAttackers ((color ==
ColorType.
WHITE ?
whites :
blacks),
(color ==
ColorType.
WHITE ?
blacks :
whites),
rank, i,
positions,
null,
attackers);
if (attackers.Count > 0)
{ // king will be under attack in this case
return false;
}
}
if (castle == CastleType.SHORT_CASTLE)
{
setPiece (side.King, rank,
ChessBoardConstants.
FILE_G);
setPiece (positions
[rank,
ChessBoardConstants.
FILE_H], rank,
ChessBoardConstants.
FILE_F);
removePiece (rank,
ChessBoardConstants.
FILE_E);
removePiece (rank,
ChessBoardConstants.
FILE_H);
lastMoveInfo.movedPiece = side.King;
lastMoveInfo.SetInfo (rank,
ChessBoardConstants.
FILE_E, rank,
ChessBoardConstants.
FILE_G, true);
}
else
{
setPiece (side.King, rank,
ChessBoardConstants.
FILE_C);
setPiece (positions
[rank,
ChessBoardConstants.
FILE_A], rank,
ChessBoardConstants.
FILE_D);
removePiece (rank,
ChessBoardConstants.
FILE_E);
removePiece (rank,
ChessBoardConstants.
FILE_A);
lastMoveInfo.movedPiece = side.King;
lastMoveInfo.SetInfo (rank,
ChessBoardConstants.
FILE_E, rank,
ChessBoardConstants.
FILE_C, true);
}
FlipTurn ();
return true;
}
protected void getSource(PieceType pieceType,
out int rank, out int file,
ChessSide side,
int dest_rank,
int dest_file, string move)
{
rank = -1;
file = -1;
ChessPiece destPiece =
positions[dest_rank, dest_file];
int exchange = 0;
if (destPiece != null)
exchange =
ChessBoardConstants.
MOVE_EXCHANGE;
if (pieceType == PieceType.KING)
{
ChessPiece cp = side.King;
rank = cp.Rank;
file = cp.File;
return;
}
IList list = side.getPiecesOfType (pieceType);
if (pieceType == PieceType.PAWN
&& move.Length > 2)
exchange =
destPiece ==
null ? ChessBoardConstants.
MOVE_ENPASSANT :
ChessBoardConstants.
MOVE_EXCHANGE;
ArrayList cands = new ArrayList ();
foreach (ChessPiece cp in list)
{
if (cp.
isValidMove (dest_rank, dest_file,
positions,
exchange |
ChessBoardConstants.
MOVE_DEBUG))
{
cands.Add (cp);
}
}
if (cands.Count == 0)
{
Console.Error.
WriteLine
(GetPositionsString ());
throw new
InvalidMoveException
(Catalog.GetString("Invalid move ") + move +
Catalog.GetString(". Couldn't find any candidate for this."));
}
if (cands.Count == 1)
{
ChessPiece cp =
(ChessPiece) cands[0];
rank = cp.Rank;
file = cp.File;
return;
}
// Ambiguity
// More than one candidates
char ch;
int movelen = move.Length;
if (cands.Count == 2)
{
if (movelen < 3)
throw new
InvalidMoveException
(Catalog.GetString("Insufficient chars in move ")
+ move);
ch = move[move.Length - 3];
if (ch >= 'a' && ch <= 'h')
{
// find the piece with matching file
foreach (ChessPiece temp
in cands)
{
if (ch ==
'a' +
temp.File)
{
rank = temp.Rank;
file = temp.File;
return;
}
}
}
else if (ch >= '1' && ch <= '8')
{
foreach (ChessPiece temp
in cands)
{
if (ch ==
'1' +
temp.Rank)
{
rank = temp.Rank;
file = temp.File;
return;
}
}
}
else
{
throw new
InvalidMoveException
(Catalog.GetString("Invalid move ") +
move);
}
}
else
{
if (movelen < 4)
throw new
InvalidMoveException
(Catalog.GetString("Invalid move ") +
move);
char file_ch =
move[move.Length - 3];
char rank_ch =
move[move.Length - 4];
rank = rank_ch - 'a';
file = file_ch - '1';
}
}
private void StartGame(ChessSide whites,
ChessSide blacks)
{
/* clear */
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
positions[i, j] = null;
turn = ColorType.WHITE;
this.whites = whites;
this.blacks = blacks;
updatePositions ();
gameStatus = GAME_STATUS_PLAYING;
}
private static void GetPieceForFENChar(char fench,
ChessSide
whites,
ChessSide
blacks,
int rank,
int file,
out ChessPiece
piece)
{
ColorType color;
ChessSide myside, oppside;
if (Char.IsUpper (fench))
{
color = ColorType.WHITE;
myside = whites;
oppside = blacks;
}
else
{
color = ColorType.BLACK;
myside = blacks;
oppside = whites;
}
char ch = Char.ToLower (fench);
switch (ch)
{
case 'p':
piece = new Pawn (color, rank, file,
myside, oppside);
break;
case 'k':
piece = new King (color, rank, file,
myside, oppside);
break;
case 'q':
piece = new Queen (color, rank,
file, myside,
oppside);
break;
case 'b':
piece = new Bishop (color, rank,
file, myside,
oppside);
break;
case 's':
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case 'n':
piece = new Knight (color, rank,
file, myside,
oppside);
break;
case 'r':
piece = new Rook (color, rank, file,
myside, oppside);
break;
default:
throw new
ChessException
(Catalog.GetString("Invalid piece type ") +
ch);
}
}
public virtual string getNotation(ChessSide side,
ChessPiece[,]
positions, int sr,
int sf, int dr,
int df,
PromotionType
promotion_type)
{
int count = 0;
IList cands = getNotationCandidates ();
if (cands != null && cands.Count > 1)
{
foreach (ChessPiece cand in cands)
{
if (cand.
isValidMove (dr, df,
positions,
ChessBoardConstants.
MOVE_EXCHANGE))
count++;
}
}
string str = "";
string dest_square =
"" + (char) ('a' + df) + (dr + 1);
if (positions[dr, df] != null)
dest_square = 'x' + dest_square;
if (count <= 1)
{
str = getNotationPrefix () +
dest_square;
}
else if (count == 2)
{
str = getNotationPrefix ();
if (((ChessPiece) cands[0]).File == ((ChessPiece) cands[1]).File) // Both on the same file
str += (sr + 1);
else
str += (char) ('a' + sf);
str += dest_square;
}
else
{
// more than two candidates
str = getNotationPrefix ();
str = str + (char) ('a' + sf) +
(sr + 1) + dest_square;
}
switch (promotion_type)
{
case PromotionType.QUEEN:
str += "=Q";
break;
case PromotionType.ROOK:
str += "=R";
break;
case PromotionType.BISHOP:
str += "=B";
break;
case PromotionType.KNIGHT:
str += "=N";
break;
}
return str;
}
private static void FillDefaultPieces(ColorType
color,
ChessSide side,
ChessSide opp)
{
/* Add pawns */
int rank;
rank = color ==
ColorType.WHITE ? ChessBoardConstants.
RANK_2 : ChessBoardConstants.RANK_7;
for (int file = ChessBoardConstants.FILE_A;
file <= ChessBoardConstants.FILE_H;
file++)
{
side.addPiece (new
Pawn (color, rank,
file, side,
opp));
}
rank = color ==
ColorType.WHITE ? ChessBoardConstants.
RANK_1 : ChessBoardConstants.RANK_8;
side.addPiece (new
Rook (color, rank,
ChessBoardConstants.
FILE_A, side, opp));
side.addPiece (new
Knight (color, rank,
ChessBoardConstants.
FILE_B, side, opp));
side.addPiece (new
Bishop (color, rank,
ChessBoardConstants.
FILE_C, side, opp));
side.addPiece (new
Queen (color, rank,
ChessBoardConstants.
FILE_D, side, opp));
side.addPiece (new
King (color, rank,
ChessBoardConstants.
FILE_E, side, opp));
side.addPiece (new
Bishop (color, rank,
ChessBoardConstants.
FILE_F, side, opp));
side.addPiece (new
Knight (color, rank,
ChessBoardConstants.
FILE_G, side, opp));
side.addPiece (new
Rook (color, rank,
ChessBoardConstants.
FILE_H, side, opp));
}
public BattleSituation(Situation situation, ChessSide side = ChessSide.Red)
{
this.situation = situation;
InitEvaluate();
}
private static void GetPositions(ChessSide white, ChessSide black)
{
}
/* This returns the attackers of (myking_rank,myking_file) square in the position
* described by positions. 'ignore' will be ignored.
*/
public static void getAttackers(ChessSide myside,
ChessSide oppside,
int myking_rank,
int myking_file,
ChessPiece[,]
positions,
ChessPiece ignore,
IList attackers)
{
ArrayList enemy_pieces = new ArrayList ();
enemy_pieces.AddRange (oppside.Queens);
enemy_pieces.AddRange (oppside.Rooks);
enemy_pieces.AddRange (oppside.Bishops);
enemy_pieces.AddRange (oppside.Knights);
enemy_pieces.AddRange (oppside.Pawns);
foreach (ChessPiece cp in enemy_pieces)
{
if (ignore != null
&& cp.Equals (ignore))
continue;
if (cp.
isValidMove (myking_rank,
myking_file,
positions,
ChessBoardConstants.
MOVE_DONT_CHECK_KINGS_EXPOSURE
|
ChessBoardConstants.
MOVE_EXCHANGE))
{
attackers.Add (cp);
}
}
}
