/// <summary>
/// Ctor
/// </summary>
/// <param name="eOriginalPiece"> Piece which has been eaten if any</param>
/// <param name="iStartPos"> Starting position</param>
/// <param name="iEndPos"> Ending position</param>
/// <param name="eType"> Move type</param>
public Move(ChessBoard.PieceE eOriginalPiece, int iStartPos, int iEndPos, TypeE eType)
{
OriginalPiece = eOriginalPiece;
StartPos = (byte)iStartPos;
EndPos = (byte)iEndPos;
Type = eType;
}
/// <summary>
/// Update the current board packing
/// </summary>
/// <param name="iPos"> Position of the new piece</param>
/// <param name="eNewPiece"> New piece</param>
public void UpdateCurrentPackedBoard(int iPos, ChessBoard.PieceE eNewPiece)
{
long lNewPiece;
long lMask;
int iSlotInValue;
iSlotInValue = (iPos & 15) << 2;
lNewPiece = ((long)eNewPiece & 15) << iSlotInValue;
lMask = (long)15 << iSlotInValue;
if (iPos < 16)
{
m_packedBoardCurrent.m_lVal1 = (m_packedBoardCurrent.m_lVal1 & ~lMask) | lNewPiece;
}
else if (iPos < 32)
{
m_packedBoardCurrent.m_lVal2 = (m_packedBoardCurrent.m_lVal2 & ~lMask) | lNewPiece;
}
else if (iPos < 48)
{
m_packedBoardCurrent.m_lVal3 = (m_packedBoardCurrent.m_lVal3 & ~lMask) | lNewPiece;
}
else
{
m_packedBoardCurrent.m_lVal4 = (m_packedBoardCurrent.m_lVal4 & ~lMask) | lNewPiece;
}
}
public Figurice PieceE2Figurice(ChessBoard.PieceE f) //Prebacivanje njegovih u moje figurice
{
f &= ChessBoard.PieceE.PieceMask;
switch (f)
{
case ChessBoard.PieceE.Pawn:
return(Figurice.Pesak);
case ChessBoard.PieceE.Knight:
return(Figurice.Skakac);
case ChessBoard.PieceE.Bishop:
return(Figurice.Lovac);
case ChessBoard.PieceE.Rook:
return(Figurice.Top);
case ChessBoard.PieceE.Queen:
return(Figurice.Kraljica);
case ChessBoard.PieceE.King:
return(Figurice.Kralj);
default:
return(Figurice.Nista);
}
}
/// <summary>
/// Transform a ChessBoard piece into a ChessPiece enum
/// </summary>
/// <param name="ePiece"></param>
/// <returns></returns>
private static ChessPiece GetChessPieceFromPiece(ChessBoard.PieceE ePiece)
{
ChessPiece eRetVal;
switch (ePiece)
{
case ChessBoard.PieceE.Pawn | ChessBoard.PieceE.White:
eRetVal = ChessPiece.White_Pawn;
break;
case ChessBoard.PieceE.Knight | ChessBoard.PieceE.White:
eRetVal = ChessPiece.White_Knight;
break;
case ChessBoard.PieceE.Bishop | ChessBoard.PieceE.White:
eRetVal = ChessPiece.White_Bishop;
break;
case ChessBoard.PieceE.Rook | ChessBoard.PieceE.White:
eRetVal = ChessPiece.White_Rook;
break;
case ChessBoard.PieceE.Queen | ChessBoard.PieceE.White:
eRetVal = ChessPiece.White_Queen;
break;
case ChessBoard.PieceE.King | ChessBoard.PieceE.White:
eRetVal = ChessPiece.White_King;
break;
case ChessBoard.PieceE.Pawn | ChessBoard.PieceE.Black:
eRetVal = ChessPiece.Black_Pawn;
break;
case ChessBoard.PieceE.Knight | ChessBoard.PieceE.Black:
eRetVal = ChessPiece.Black_Knight;
break;
case ChessBoard.PieceE.Bishop | ChessBoard.PieceE.Black:
eRetVal = ChessPiece.Black_Bishop;
break;
case ChessBoard.PieceE.Rook | ChessBoard.PieceE.Black:
eRetVal = ChessPiece.Black_Rook;
break;
case ChessBoard.PieceE.Queen | ChessBoard.PieceE.Black:
eRetVal = ChessPiece.Black_Queen;
break;
case ChessBoard.PieceE.King | ChessBoard.PieceE.Black:
eRetVal = ChessPiece.Black_King;
break;
default:
eRetVal = ChessPiece.None;
break;
}
return(eRetVal);
}
/// <summary>
/// Set the chess piece control
/// </summary>
/// <param name="iPos"> Piece position</param>
/// <param name="ePiece"> Piece</param>
private void SetPieceControl(int iPos, ChessBoard.PieceE ePiece)
{
Border border;
Control controlPiece;
Label label;
border = m_arrBorder[iPos];
controlPiece = m_pieceSet[ePiece];
if (controlPiece != null)
{
controlPiece.Margin = new Thickness(1);
}
m_arrPiece[iPos] = ePiece;
if (controlPiece == null) // && m_bDesignMode) {
{
label = new Label();
label.Content = " ";
label.FontSize = 0.1;
controlPiece = label;
controlPiece.HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch;
controlPiece.VerticalAlignment = System.Windows.VerticalAlignment.Stretch;
//controlPiece.Background = Brushes.Red;
}
border.Child = controlPiece;
}
public Test(PieceSet pieceSet)
: this()
{
m_pieceSet = pieceSet;
m_ePiece = ChessBoard.PieceE.Pawn;
ShowControl();
}
//*********************************************************
//
/// <summary>
/// Enum the eated pieces
/// </summary>
/// <returns>
/// List of eated pieces
/// </returns>
//
//*********************************************************
private ChessBoard.PieceE[] EnumPiece() {
List<ChessBoard.PieceE> arrPieces;
ChessBoard.PieceE[] arrPossiblePiece;
ChessBoard.PieceE ePiece;
int iEated;
arrPossiblePiece = new ChessBoard.PieceE[] { ChessBoard.PieceE.King,
ChessBoard.PieceE.Queen,
ChessBoard.PieceE.Rook,
ChessBoard.PieceE.Bishop,
ChessBoard.PieceE.Knight,
ChessBoard.PieceE.Pawn };
arrPieces = new List<ChessBoard.PieceE>(16);
if (m_bDesignMode) {
arrPieces.Add(ChessBoard.PieceE.None);
}
foreach (ChessBoard.PieceE ePossiblePiece in arrPossiblePiece) {
if (m_bDesignMode) {
ePiece = ePossiblePiece;
arrPieces.Add(ePiece);
ePiece |= ChessBoard.PieceE.Black;
arrPieces.Add(ePiece);
} else {
ePiece = ePossiblePiece;
if (m_bColor) {
ePiece |= ChessBoard.PieceE.Black;
}
iEated = m_chessCtl.ChessBoard.GetEatedPieceCount(ePiece);
for (int iIndex = 0; iIndex < iEated; iIndex++) {
arrPieces.Add(ePiece);
}
}
}
return(arrPieces.ToArray());
}
private void button1_Click(object sender, RoutedEventArgs e)
{
if (m_ePiece == ChessBoard.PieceE.King) {
m_ePiece = ChessBoard.PieceE.Pawn;
} else {
m_ePiece++;
}
ShowControl();
}
/// <summary>
/// Update the Zobrist key using the specified move
/// </summary>
/// <param name="i64ZobristKey">Zobrist key</param>
/// <param name="iPos"> Piece position</param>
/// <param name="eOldPiece"> Old value</param>
/// <param name="eNewPiece"> New value</param>
public static long UpdateZobristKey(long i64ZobristKey, int iPos, ChessBoard.PieceE eOldPiece, ChessBoard.PieceE eNewPiece)
{
int iBaseIndex;
iBaseIndex = iPos << 4;
i64ZobristKey ^= s_pi64RndTable[iBaseIndex + ((int)eOldPiece)] ^
s_pi64RndTable[iBaseIndex + ((int)eNewPiece)];
return(i64ZobristKey);
}
/// <summary>
/// Gets the specified piece
/// </summary>
/// <param name="ePiece"></param>
/// <returns>
/// User control expressing the piece
/// </returns>
public UserControl this[ChessBoard.PieceE ePiece] {
get {
UserControl userControlRetVal;
ChessPiece eChessPiece;
eChessPiece = GetChessPieceFromPiece(ePiece);
userControlRetVal = (eChessPiece == ChessPiece.None) ? null : LoadPiece(eChessPiece);
return(userControlRetVal);
}
}
private void button1_Click(object sender, RoutedEventArgs e)
{
if (m_ePiece == ChessBoard.PieceE.King)
{
m_ePiece = ChessBoard.PieceE.Pawn;
}
else
{
m_ePiece++;
}
ShowControl();
}
public Igrac PieceE2Igrac(ChessBoard.PieceE f) //Prebacivanje njegove u moju boju
{
f &= ~ChessBoard.PieceE.PieceMask;
switch (f)
{
case ChessBoard.PieceE.Black:
return(Igrac.Crni);
default:
return(Igrac.Beli);
}
}
/// <summary>
/// Enumerate the pieces which must be shown in the control
/// </summary>
/// <returns>
/// Array of pieces
/// </returns>
private ChessBoard.PieceE[] EnumPiece()
{
ChessBoard.PieceE[] arrPieces;
ChessBoard.PieceE[] arrPossiblePiece;
ChessBoard.PieceE ePiece;
int iEated;
int iPos;
arrPieces = new ChessBoard.PieceE[16];
for (int i = 0; i < 16; i++)
{
arrPieces[i] = ChessBoard.PieceE.None;
}
arrPossiblePiece = new ChessBoard.PieceE[] { ChessBoard.PieceE.King,
ChessBoard.PieceE.Queen,
ChessBoard.PieceE.Rook,
ChessBoard.PieceE.Bishop,
ChessBoard.PieceE.Knight,
ChessBoard.PieceE.Pawn };
iPos = 0;
if (m_bDesignMode)
{
iPos++;
}
foreach (ChessBoard.PieceE ePossiblePiece in arrPossiblePiece)
{
if (m_bDesignMode)
{
ePiece = ePossiblePiece;
arrPieces[iPos++] = ePiece;
ePiece |= ChessBoard.PieceE.Black;
arrPieces[iPos++] = ePiece;
}
else
{
ePiece = ePossiblePiece;
if (Color)
{
ePiece |= ChessBoard.PieceE.Black;
}
iEated = m_chessBoardCtl.ChessBoard.GetEatedPieceCount(ePiece);
for (int iIndex = 0; iIndex < iEated; iIndex++)
{
arrPieces[iPos++] = ePiece;
}
}
}
return(arrPieces);
}
/// <summary>
/// Update the Zobrist key using the specified move
/// </summary>
/// <param name="i64ZobristKey">Zobrist key</param>
/// <param name="iPos1"> Piece position</param>
/// <param name="eOldPiece1"> Old value</param>
/// <param name="eNewPiece1"> New value</param>
/// <param name="iPos2"> Piece position</param>
/// <param name="eOldPiece2"> Old value</param>
/// <param name="eNewPiece2"> New value</param>
public static long UpdateZobristKey(long i64ZobristKey,
int iPos1,
ChessBoard.PieceE eOldPiece1,
ChessBoard.PieceE eNewPiece1,
int iPos2,
ChessBoard.PieceE eOldPiece2,
ChessBoard.PieceE eNewPiece2)
{
int iBaseIndex1;
int iBaseIndex2;
iBaseIndex1 = iPos1 << 4;
iBaseIndex2 = iPos2 << 4;
i64ZobristKey ^= s_pi64RndTable[iBaseIndex1 + ((int)eOldPiece1)] ^
s_pi64RndTable[iBaseIndex1 + ((int)eNewPiece1)] ^
s_pi64RndTable[iBaseIndex2 + ((int)eOldPiece2)] ^
s_pi64RndTable[iBaseIndex2 + ((int)eNewPiece2)];
return(i64ZobristKey);
}
/// <summary>
/// Load from stream
/// </summary>
/// <param name="reader"> Binary reader</param>
public void LoadFromStream(System.IO.BinaryReader reader)
{
int iNewSize;
ChessBoard.PieceE[] peBoard;
PackedBoard packedBoard;
long l64ZobristKey;
packedBoard.m_lVal1 = 0;
packedBoard.m_lVal2 = 0;
packedBoard.m_lVal3 = 0;
packedBoard.m_lVal4 = 0;
packedBoard.m_eInfo = (ChessBoard.BoardStateMaskE) 0;
Array.Clear(m_arrHashCount, 0, m_arrHashCount.Length);
m_packedBoardCurrent.LoadFromStream(reader);
peBoard = new ChessBoard.PieceE[64];
m_iMoveCount = reader.ReadInt32();
iNewSize = m_iPackedBoardArraySize;
while (m_iMoveCount > iNewSize)
{
iNewSize *= 2;
}
if (iNewSize != m_iPackedBoardArraySize)
{
m_arrPackedBoard = new PackedBoard[iNewSize];
m_iPackedBoardArraySize = iNewSize;
}
for (int iIndex = 0; iIndex < m_iMoveCount; iIndex++)
{
packedBoard.LoadFromStream(reader);
m_arrPackedBoard[iIndex] = packedBoard;
UnpackBoard(packedBoard, peBoard);
l64ZobristKey = ZobristKey.ComputeBoardZobristKey(peBoard) ^ (int)packedBoard.m_eInfo;
m_arrHashCount[l64ZobristKey & 16383]++;
}
m_iCountMoveDepth = reader.ReadInt32();
for (int iIndex = 0; iIndex <= m_iCountMoveDepth; iIndex++)
{
m_arrCountMove[iIndex] = reader.ReadInt16();
}
}
/// <summary>
/// Find a move using the specification
/// </summary>
/// <param name="ePlayerColor"> Color moving</param>
/// <param name="ePiece"> Piece moving</param>
/// <param name="iStartCol"> Starting column of the move or -1 if not specified</param>
/// <param name="iStartRow"> Starting row of the move or -1 if not specified</param>
/// <param name="iEndPos"> Ending position of the move</param>
/// <param name="eMoveType"> Type of move. Use for discriminating between different pawn promotion.</param>
/// <param name="strMove"> Move</param>
/// <param name="iTruncated"> Truncated count</param>
/// <param name="movePos"> Move position</param>
/// <returns>
/// Moving position or -1 if error
/// </returns>
private int FindPieceMove(ChessBoard.PlayerColorE ePlayerColor, ChessBoard.PieceE ePiece, int iStartCol, int iStartRow, int iEndPos, ChessBoard.MoveTypeE eMoveType, string strMove, ref int iTruncated, ref ChessBoard.MovePosS movePos)
{
int iRetVal = -1;
List <ChessBoard.MovePosS> arrMovePos;
int iCol;
int iRow;
ePiece = ePiece | ((ePlayerColor == ChessBoard.PlayerColorE.Black) ? ChessBoard.PieceE.Black : ChessBoard.PieceE.White);
arrMovePos = m_chessBoard.EnumMoveList(ePlayerColor);
foreach (ChessBoard.MovePosS move in arrMovePos)
{
if ((int)move.EndPos == iEndPos && m_chessBoard[(int)move.StartPos] == ePiece)
{
if (eMoveType == ChessBoard.MoveTypeE.Normal || (move.Type & ChessBoard.MoveTypeE.MoveTypeMask) == eMoveType)
{
iCol = (int)move.StartPos & 7;
iRow = (int)move.StartPos >> 3;
if ((iStartCol == -1 || iStartCol == iCol) &&
(iStartRow == -1 || iStartRow == iRow))
{
if (iRetVal != -1)
{
throw new PgnParserException("More then one piece found for this move - " + strMove, GetCodeInError());
}
movePos = move;
iRetVal = (int)move.StartPos + ((int)move.EndPos << 8);
m_chessBoard.DoMove(move);
}
}
}
}
if (iRetVal == -1)
{
if (m_bDiagnose)
{
throw new PgnParserException("Unable to find compatible move - " + strMove, GetCodeInError());
}
iTruncated++;
}
return(iRetVal);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="eOriginalPiece"> Piece which has been eaten if any</param>
/// <param name="iStartPos"> Starting position</param>
/// <param name="iEndPos"> Ending position</param>
/// <param name="eType"> Move type</param>
/// <param name="strComment"> Move comment</param>
/// <param name="iPermutationCount">Number of permutations searched in the find for best move</param>
/// <param name="iSearchDepth"> Maximum depth of the search in the find for best move</param>
/// <param name="iCacheHit"> Number of cache hit in the find for best move</param>
/// <param name="iNag"> Numeric Annotation Glyph</param>
public MoveExt(ChessBoard.PieceE eOriginalPiece,
int iStartPos,
int iEndPos,
Move.TypeE eType,
string strComment,
int iPermutationCount,
int iSearchDepth,
int iCacheHit,
int iNag)
{
Move.OriginalPiece = eOriginalPiece;
Move.StartPos = (byte)iStartPos;
Move.EndPos = (byte)iEndPos;
Move.Type = eType;
Comment = strComment;
PermutationCount = iPermutationCount;
SearchDepth = iSearchDepth;
CacheHit = iCacheHit;
NAG = iNag;
TimeToCompute = TimeSpan.Zero;
}
/// <summary>
/// Enumerate the pieces which must be shown in the control
/// </summary>
/// <returns>
/// Array of pieces
/// </returns>
private ChessBoard.PieceE[] EnumPiece()
{
ChessBoard.PieceE[] arrPieces;
ChessBoard.PieceE[] arrPossiblePiece;
ChessBoard.PieceE ePiece;
int iEated;
int iPos;
arrPieces = new ChessBoard.PieceE[16];
for (int i = 0; i < 16; i++) {
arrPieces[i] = ChessBoard.PieceE.None;
}
arrPossiblePiece = new ChessBoard.PieceE[] { ChessBoard.PieceE.King,
ChessBoard.PieceE.Queen,
ChessBoard.PieceE.Rook,
ChessBoard.PieceE.Bishop,
ChessBoard.PieceE.Knight,
ChessBoard.PieceE.Pawn };
iPos = 0;
if (m_bDesignMode) {
iPos++;
}
foreach (ChessBoard.PieceE ePossiblePiece in arrPossiblePiece) {
if (m_bDesignMode) {
ePiece = ePossiblePiece;
arrPieces[iPos++] = ePiece;
ePiece |= ChessBoard.PieceE.Black;
arrPieces[iPos++] = ePiece;
} else {
ePiece = ePossiblePiece;
if (Color) {
ePiece |= ChessBoard.PieceE.Black;
}
iEated = m_chessBoardCtl.ChessBoard.GetEatedPieceCount(ePiece);
for (int iIndex = 0; iIndex < iEated; iIndex++) {
arrPieces[iPos++] = ePiece;
}
}
}
return(arrPieces);
}
/// <summary>
/// Decode the piece represent by a character
/// </summary>
/// <param name="chr"> Character to decode</param>
/// <param name="ePiece"> Resulting piece</param>
/// <returns>
/// true if succeed, false if error
/// </returns>
public static bool DecodePiece(char chr, out ChessBoard.PieceE ePiece)
{
bool bRetVal = true;
switch (chr)
{
case '-':
ePiece = ChessBoard.PieceE.None;
break;
case 'P':
ePiece = ChessBoard.PieceE.Pawn | ChessBoard.PieceE.White;
break;
case 'N':
ePiece = ChessBoard.PieceE.Knight | ChessBoard.PieceE.White;
break;
case 'B':
ePiece = ChessBoard.PieceE.Bishop | ChessBoard.PieceE.White;
break;
case 'R':
ePiece = ChessBoard.PieceE.Rook | ChessBoard.PieceE.White;
break;
case 'Q':
ePiece = ChessBoard.PieceE.Queen | ChessBoard.PieceE.White;
break;
case 'K':
ePiece = ChessBoard.PieceE.King | ChessBoard.PieceE.White;
break;
case 'p':
ePiece = ChessBoard.PieceE.Pawn | ChessBoard.PieceE.Black;
break;
case 'n':
ePiece = ChessBoard.PieceE.Knight | ChessBoard.PieceE.Black;
break;
case 'b':
ePiece = ChessBoard.PieceE.Bishop | ChessBoard.PieceE.Black;
break;
case 'r':
ePiece = ChessBoard.PieceE.Rook | ChessBoard.PieceE.Black;
break;
case 'q':
ePiece = ChessBoard.PieceE.Queen | ChessBoard.PieceE.Black;
break;
case 'k':
ePiece = ChessBoard.PieceE.King | ChessBoard.PieceE.Black;
break;
default:
ePiece = ChessBoard.PieceE.None;
bRetVal = false;
break;
}
return(bRetVal);
}
/// <summary>
/// Ctor
/// </summary>
public Style12MoveLine()
{
Board = new ChessBoard.PieceE[64];
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="iPos"> Position of the square</param>
/// <param name="ePiece"> Piece</param>
public QueryPieceEventArgs(int iPos, ChessBoard.PieceE ePiece)
{
Pos = iPos; Piece = ePiece;
}
//*********************************************************
//
/// <summary>
/// Load from stream
/// </summary>
/// <param name="reader"> Binary reader</param>
//
//*********************************************************
public void LoadFromStream(System.IO.BinaryReader reader) {
int iNewSize;
ChessBoard.PieceE[] peBoard;
PackedBoard packedBoard;
long l64ZobristKey;
packedBoard.m_lVal1 = 0;
packedBoard.m_lVal2 = 0;
packedBoard.m_lVal3 = 0;
packedBoard.m_lVal4 = 0;
packedBoard.m_eInfo = (ChessBoard.BoardStateMaskE)0;
Array.Clear(m_arrHashCount, 0, m_arrHashCount.Length);
m_packedBoardCurrent.LoadFromStream(reader);
peBoard = new ChessBoard.PieceE[64];
m_iMoveCount = reader.ReadInt32();
iNewSize = m_iPackedBoardArraySize;
while (m_iMoveCount > iNewSize) {
iNewSize *= 2;
}
if (iNewSize != m_iPackedBoardArraySize) {
m_arrPackedBoard = new PackedBoard[iNewSize];
m_iPackedBoardArraySize = iNewSize;
}
for (int iIndex = 0; iIndex < m_iMoveCount; iIndex++) {
packedBoard.LoadFromStream(reader);
m_arrPackedBoard[iIndex] = packedBoard;
UnpackBoard(packedBoard, peBoard);
l64ZobristKey = ZobristKey.ComputeBoardZobristKey(peBoard) ^ (int)packedBoard.m_eInfo;
m_arrHashCount[l64ZobristKey & 16383]++;
}
m_iCountMoveDepth = reader.ReadInt32();
for (int iIndex = 0; iIndex <= m_iCountMoveDepth; iIndex++) {
m_arrCountMove[iIndex] = reader.ReadInt16();
}
}
public Test(PieceSet pieceSet) : this()
{
m_pieceSet = pieceSet;
m_ePiece = ChessBoard.PieceE.Pawn;
ShowControl();
}
