/// <summary>
/// ChessPiece Constructor
/// </summary>
/// <param name="aPieceColor"></param>
/// <param name="aPieceType"></param>
/// <param name="aChessSquare"></param>
internal ChessPiece(EnumPieceColor aPieceColor, EnumPieceType aPieceType, ChessSquare aChessSquare)
{
chessPieceColor = aPieceColor;
chessPieceType = aPieceType;
chessPieceID = (EnumPieceID)((int)chessPieceColor + (int)chessPieceType);
chessSquare = aChessSquare;
EnumSquareID sid = chessSquare.GetSquareID();
ChessImageConstants.parserChessBoardSquares[sid] = chessPieceID;
isEnabled = true;
}
/// <summary>
/// ChessPiece Constructor
/// </summary>
/// <param name="aPieceColor"></param>
/// <param name="aPieceType"></param>
/// <param name="aChessSquare"></param>
internal ChessPiece(EnumPieceColor aPieceColor, EnumPieceType aPieceType, ChessSquare aChessSquare)
{
chessPieceColor = aPieceColor;
chessPieceType = aPieceType;
chessPieceID = (EnumPieceID)((int)chessPieceColor + (int)chessPieceType);
chessSquare = aChessSquare;
EnumSquareID sid = chessSquare.GetSquareID();
ChessImageConstants.parserChessBoardSquares[sid] = chessPieceID;
isCastlingPossible = ((aPieceType == EnumPieceType.King) || ((aPieceType == EnumPieceType.Rook)));
isEnabled = true; // TODO was false
}
/// <summary>
/// GetLocationCalculator
/// </summary>
/// <param name="chessPieceType"></param>
/// <param name="aChessPlayer"></param>
/// <returns>ChessLocationCalculator</returns>
internal ChessLocationCalculator GetLocationCalculator(EnumPieceType chessPieceType, ChessPlayer aChessPlayer)
{
switch(chessPieceType)
{
case EnumPieceType.Pawn:
{
if (pawnCalculator == null)
pawnCalculator = new ChessLocationCalculatorPawn(chessBoard);
pawnCalculator.SetCurrentPlayer(aChessPlayer);
return pawnCalculator;
}
case EnumPieceType.Rook:
{
if (rookCalculator == null)
rookCalculator = new ChessLocationCalculatorRook(chessBoard);
return rookCalculator;
}
case EnumPieceType.Knight:
{
if (knightCalculator == null)
knightCalculator = new ChessLocationCalculatorKnight(chessBoard);
return knightCalculator;
}
case EnumPieceType.Bishop:
{
if (bishopCalculator == null)
bishopCalculator = new ChessLocationCalculatorBishop(chessBoard);
return bishopCalculator;
}
case EnumPieceType.Queen:
{
if (queenCalculator == null)
queenCalculator = new ChessLocationCalculatorQueen(chessBoard);
return queenCalculator;
}
case EnumPieceType.King:
{
if (kingCalculator == null)
kingCalculator = new ChessLocationCalculatorKing(chessBoard);
return kingCalculator;
}
}
throw (new Exception("LocationCalculatorFactory.GetLocationCalculator : Invalid Chess Piece Type"));
}
// Static Functions
/// <summary>
/// Returns the movement type based on specified
/// </summary>
/// <param name="_enumPiece"> The movement of the piece type to be retrieved </param>
/// <returns> Returns an array of movements </returns>
public static int[,] GetMovementType(EnumPieceType _enumPiece)
{
switch (_enumPiece)
{
case EnumPieceType.Bishop: return(msarr2_nBishop);
case EnumPieceType.King: return(msarr2_nKing);
case EnumPieceType.Knight: return(msarr2_nKnight);
case EnumPieceType.Rook: return(msarr2_nRook);
default: return(null);
}
}
/// <summary>
/// GetChessPieceRectangle by type and color
/// </summary>
/// <param name="aPieceType"></param>
/// <param name="aPieceColor"></param>
/// <returns>ChessPieceRectangle</returns>
public ChessPieceRectangle GetChessPieceRectangle(EnumPieceType aPieceType, EnumPieceColor aPieceColor)
{
switch(aPieceType)
{
case EnumPieceType.Pawn:
if (aPieceColor == EnumPieceColor.White)
return whitePawnRectangle;
else
return blackPawnRectangle;
case EnumPieceType.Rook:
if (aPieceColor == EnumPieceColor.White)
return whiteRookRectangle;
else
return blackRookRectangle;
case EnumPieceType.Knight:
if (aPieceColor == EnumPieceColor.White)
return whiteKnightRectangle;
else
return blackKnightRectangle;
case EnumPieceType.Bishop:
if (aPieceColor == EnumPieceColor.White)
return whiteBishopRectangle;
else
return blackBishopRectangle;
case EnumPieceType.Queen:
if (aPieceColor == EnumPieceColor.White)
return whiteQueenRectangle;
else
return blackQueenRectangle;
case EnumPieceType.King:
if (aPieceColor == EnumPieceColor.White)
return whiteKingRectangle;
else
return blackKingRectangle;
case EnumPieceType.None:
return null;
}
throw( new Exception("ChessPieceFactory.GetChessPieceRectangle : Unknown EnumPieceType") );
}
/// <summary>
/// ChessPiece Constructor
/// </summary>
/// <param name="aChessPieceID"></param>
internal ChessPiece(EnumPieceID aChessPieceID, ChessSquare aChessSquare)
{
chessSquare = aChessSquare;
if (aChessPieceID == EnumPieceID.BlackKing)
{
chessPieceType = EnumPieceType.King;
chessPieceColor = EnumPieceColor.Black;
}
else if (aChessPieceID == EnumPieceID.WhiteKing)
{
chessPieceType = EnumPieceType.King;
chessPieceColor = EnumPieceColor.White;
}
chessPieceID = aChessPieceID;
isEnabled = false;
}
/// <summary>
/// ChessPiece Constructor
/// </summary>
/// <param name="aChessPieceID"></param>
internal ChessPiece(EnumPieceID aChessPieceID, ChessSquare aChessSquare)
{
chessSquare = aChessSquare;
if (aChessPieceID == EnumPieceID.BlackKing)
{
chessPieceType = EnumPieceType.King;
chessPieceColor = EnumPieceColor.Black;
}
else if (aChessPieceID == EnumPieceID.WhiteKing)
{
chessPieceType = EnumPieceType.King;
chessPieceColor = EnumPieceColor.White;
}
chessPieceID = aChessPieceID;
isCastlingPossible = ((chessPieceType == EnumPieceType.King) || ((chessPieceType == EnumPieceType.Rook)));
isEnabled = false;
}
/// <summary>
/// CreateChessPiece by square piece type and piece color
/// </summary>
/// <param name="aChessSquare"></param>
/// <param name="aChessPieceType"></param>
/// <param name="aChessPieceColor"></param>
/// <returns>ChessPiece</returns>
private ChessPiece CreateChessPiece(ChessSquare aChessSquare, EnumPieceType aChessPieceType, EnumPieceColor aChessPieceColor)
{
ChessPiece chessPiece = new ChessPiece(aChessPieceColor, aChessPieceType, aChessSquare);
EnumSquareID squareID = aChessSquare.GetSquareID();
Point aLocation = new Point(aChessSquare.GetStartLocation().X + ChessImageConstants.ChessPieceLeft,
aChessSquare.GetStartLocation().Y + ChessImageConstants.ChessPieceTop);
chessPiece.SetStartLocation(aLocation);
chessPiece.SetChessSquare(aChessSquare);
aChessSquare.SetChessPiece(chessPiece);
if (aChessPieceColor == EnumPieceColor.White)
{
whitePieceList.Add(chessPiece);
}
else
{
blackPieceList.Add(chessPiece);
}
return chessPiece;
}
public override void ClearSpace()
{
PlayerOwns = 0;
PlayerPiece = EnumPieceType.None;
PlayerColor = cs.Transparent;
}
/// <summary>
/// SetPieceType
/// </summary>
/// <param name="aChessPieceType"></param>
internal void SetPieceType(EnumPieceType aChessPieceType)
{
chessPieceType = aChessPieceType;
}
private int DeterminerMeilleurEmplacement(EnumPieceType pieceAPlacer)
{
bestEmplacement.x = -1;
bestEmplacement.y = -1;
bestEmplacement.rotation = -1;
switch (pieceAPlacer)
{
case EnumPieceType.I_block:
//recherche meilleur emplacement avec la barre horizontal (rotation = 1)
for (int i = 0; i < nbCasesX - 3; i++)
{
int y = 0;
while (Grille[i][y].caseStatus == Case.EnumCaseStatus.Empty && Grille[i + 1][y].caseStatus == Case.EnumCaseStatus.Empty && Grille[i + 2][y].caseStatus == Case.EnumCaseStatus.Empty && Grille[i + 3][y].caseStatus == Case.EnumCaseStatus.Empty)
{
y++;
}
;
if (y > bestEmplacement.y)
{
bestEmplacement.x = i;
bestEmplacement.y = y;
bestEmplacement.rotation = 1;
}
}
//recherche meilleur emplacement avec la barre verticale (rotation = 2)
for (int i = 0; i < nbCasesX; i++)
{
int y = 0;
while (Grille[i][y].caseStatus == Case.EnumCaseStatus.Empty)
{
y++;
}
;
if (y > bestEmplacement.y)
{
bestEmplacement.x = i;
bestEmplacement.y = y;
bestEmplacement.rotation = 2;
}
}
break;
case EnumPieceType.O_block:
for (int i = 0; i < nbCasesX - 1; i++)
{
int y = 0;
while (Grille[i][y].caseStatus == Case.EnumCaseStatus.Empty && Grille[i + 1][y].caseStatus == Case.EnumCaseStatus.Empty)
{
y++;
}
;
if (y > bestEmplacement.y)
{
bestEmplacement.x = i;
bestEmplacement.y = y;
bestEmplacement.rotation = 0;
}
}
break;
case EnumPieceType.J_block:
for (int r = 1; r <= 4; r++) //rotation: 1 à 4
{
}
break;
}
return(bestEmplacement.x);
}
