public Set(Piece.Color c)
{
colorPiece = c;
if (colorPiece == Piece.Color.black)
{
startLine = 0;
startLineP = 1;
}
if (colorPiece == Piece.Color.white)
{
startLine = 7;
startLineP = 6;
}
set = new List <Piece>();
for (int i = 0; i < 8; i++)
{
set.Add(new Pion("P-" + i, colorPiece, new Coord(i, startLineP)));
}
set.Add(new Tour("T-1", colorPiece, new Coord(0, startLine)));
set.Add(new Cavalier("C-1", colorPiece, new Coord(1, startLine)));
set.Add(new Fou("F-1", colorPiece, new Coord(2, startLine)));
set.Add(new Reine("Rei", colorPiece, new Coord(3, startLine)));
set.Add(new Roi("Roi", colorPiece, new Coord(4, startLine)));
set.Add(new Fou("F-2", colorPiece, new Coord(5, startLine)));
set.Add(new Cavalier("C-2", colorPiece, new Coord(6, startLine)));
set.Add(new Tour("T-2", colorPiece, new Coord(7, startLine)));
}
public void PlayTurn()
{
//Une fois que joueur blanc a bougé une pièce, lance le tour du joueur noir
Coord FindPiece = AskCoordinateToFindYourPiece();
List <Coord> coordinates = GameBoard[FindPiece.x, FindPiece.y].GetPossibleMoves(GameBoard, FindPiece);
//Une fois que les coord pièce à déplacer sont validées
//Donne déplacements possibles par rapport aux caractéristiques de mouvement de chaque pièce
foreach (Coord cr in coordinates)
{
Console.WriteLine("Déplacements possibles : (" + cr.x + "," + cr.y + ")");
}
//Appelle la fonction Move pour déplacer la pièce choisie vers les coord stockées dans la liste
Move(FindPiece, AskCoordinateIntoAList(coordinates));
//Si joueur actuel = blanc, le prochain joueur sera le noir
if (ActualPlayer == Piece.Color.blanc)
{
ActualPlayer = Piece.Color.noir;
Console.WriteLine("Joueur noir joue");
}
else
{
ActualPlayer = Piece.Color.blanc;
Console.WriteLine("Joueur blanc joue");
}
PlayTurn();
}
public static bool SquareIsThreatened(Piece pPiece, BoardPosition bp, ChessBoard aBoard)
{
Piece.Color pieceColor = pPiece.GetColor();
List <BoardPosition> moveList;
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (aBoard.GetBoard()[i, j].HasPiece())
{
if (!(pPiece.IsSameColor(aBoard.GetBoard()[i, j].GetPiece())))
{
if (aBoard.GetBoard()[i, j].GetPiece().GetPieceType() == Piece.PieceType.QUEEN)
{
moveList = GetAvaiableMoves(new BoardPosition(i, j), aBoard);
// Console.WriteLine("Position: " + i + "," + j);
foreach (BoardPosition b in moveList)
{
// Console.Write(b.ToString() + " ");
if (b.IsSamePosition(bp))
{
return(true);
}
}
}
}
}
}
}
return(false);
}
public List <Piece> IsPieceWhoCanDisableEchec(List <Piece> pieceMakeEchec, Piece.Color color)
{
List <Piece> pieceToMustMove = new List <Piece>();
Roi king = GetKing(color);
if (king.GetPossibleMovesWhenInEchec(GameBoard, king.Coord, king) != null)
{
pieceToMustMove.Add(king);
}
foreach (Piece pieceGame in GameBoard)
{
if (pieceGame != null && pieceGame.color == color && pieceGame.name != "Roi")
{
List <Coord> movePieceGame = pieceGame.GetPossibleMoves(GameBoard, pieceGame.Coord);
if (movePieceGame != null)
{
movePieceGame.ForEach(delegate(Coord coordPieceGame)
{
pieceMakeEchec.ForEach(delegate(Piece pieceEchec)
{
if (coordPieceGame.x == pieceEchec.Coord.x && coordPieceGame.y == pieceEchec.Coord.y)
{
if (!pieceToMustMove.Contains(pieceGame))
{
pieceToMustMove.Add(pieceGame);
}
}
List <Coord> movePieceEchec = pieceEchec.GetPossibleMovesWhenMakeEchec(GameBoard, pieceEchec.Coord, king.Coord);
if (movePieceEchec != null)
{
movePieceEchec.ForEach(delegate(Coord coordPieceEchec)
{
if (coordPieceGame.x == coordPieceEchec.x && coordPieceGame.y == coordPieceEchec.y)
{
if (!pieceToMustMove.Contains(pieceGame))
{
pieceToMustMove.Add(pieceGame);
}
}
});
}
});
});
}
}
}
if (pieceToMustMove.Count == 0)
{
return(null);
}
return(pieceToMustMove);
}
public bool EnemyPieceAtLocation(Vector3 pos, Piece.Color color)
{
switch (color)
{
case Piece.Color.White:
foreach (GameObject g in Allpieces)
{
Piece p = g.GetComponent <Piece>();
if ((g.transform.position.x == pos.x && g.transform.position.z == pos.z) && p.pColor == Piece.Color.Black)
{
return(true);
}
}
return(false);
case Piece.Color.Black:
foreach (GameObject g in Allpieces)
{
Piece p = g.GetComponent <Piece>();
if ((g.transform.position.x == pos.x && g.transform.position.z == pos.z) && p.pColor == Piece.Color.White)
{
return(true);
}
}
return(false);
default:
return(false);
}
}
public void NewGame(Piece.Color playerColor)
{
aChessBoard.CleanBoard();
aChessBoard.SetPieces();
aPieceManipulator.SetCurrentColor(Piece.Color.WHITE);
aFirstPlayer = playerColor;
aChessBoardView.SetFirstPlayer(playerColor);
}
public Player(String name, Piece.Color color = Piece.Color.FREE, int wins = 0, int losses = 0, int draws = 0, bool hasTurn = false)
{
this.name = name;
this.wins = wins;
this.losses = losses;
this.draws = draws;
this.color = color;
this.hasTurn = hasTurn;
}
public PieceManipulator()
{
aPromotionManipulator = new PromotionManipulator();
isSelectingPiece = false;
selectedBoardPosition = new BoardPosition();
aCurrentColor = Piece.Color.WHITE;
selectedBoardPosition.Invalid();
listOfMoves = null;
}
public void StartGame()
{
//Initialisation plateau / cases vides et remplies
//Le premier joueur à jouer est blanc
//Les axes sont inversés donc y = abscisses et x = ordonnées
//Les ordonnées font, en partant du bas : 7 6 5 4 3 2 1 0
//Les abscisses font, en partant de la gauche : 0 1 2 3 4 5 6 7
ActualPlayer = Piece.Color.blanc;
GameBoard = new Piece[8, 8];
GameBoard[1, 0] = new Pion(Piece.Color.blanc);
GameBoard[1, 1] = new Reine(Piece.Color.blanc);
GameBoard[1, 2] = new Pion(Piece.Color.blanc);
GameBoard[1, 3] = new Pion(Piece.Color.blanc);
GameBoard[1, 4] = new Pion(Piece.Color.blanc);
GameBoard[1, 5] = new Pion(Piece.Color.blanc);
GameBoard[1, 6] = new Pion(Piece.Color.blanc);
GameBoard[1, 7] = new Pion(Piece.Color.blanc);
GameBoard[6, 0] = new Pion(Piece.Color.noir);
GameBoard[6, 1] = new Pion(Piece.Color.noir);
GameBoard[6, 2] = new Pion(Piece.Color.noir);
GameBoard[6, 3] = new Pion(Piece.Color.noir);
GameBoard[6, 4] = new Pion(Piece.Color.noir);
GameBoard[6, 5] = new Pion(Piece.Color.noir);
GameBoard[6, 6] = new Pion(Piece.Color.noir);
GameBoard[6, 7] = new Pion(Piece.Color.noir);
GameBoard[0, 4] = new Roi(Piece.Color.blanc);
GameBoard[7, 4] = new Roi(Piece.Color.noir);
GameBoard[0, 3] = new Reine(Piece.Color.blanc);
GameBoard[7, 3] = new Reine(Piece.Color.noir);
GameBoard[0, 0] = new Tour(Piece.Color.blanc);
GameBoard[0, 7] = new Tour(Piece.Color.blanc);
GameBoard[7, 0] = new Tour(Piece.Color.noir);
GameBoard[7, 7] = new Tour(Piece.Color.noir);
GameBoard[0, 1] = new Cavalier(Piece.Color.blanc);
GameBoard[0, 6] = new Cavalier(Piece.Color.blanc);
GameBoard[7, 1] = new Cavalier(Piece.Color.noir);
GameBoard[7, 6] = new Cavalier(Piece.Color.noir);
GameBoard[0, 2] = new Fou(Piece.Color.blanc);
GameBoard[0, 5] = new Fou(Piece.Color.blanc);
GameBoard[7, 2] = new Fou(Piece.Color.noir);
GameBoard[7, 5] = new Fou(Piece.Color.noir);
PrintBoard();
Console.WriteLine("Joueur blanc joue");
PlayTurn();
}
/**
* NextTurn()
*
* Déclenche le prochain tour en modifiant la propriété PlayingNow
*
* @author Axel Floquet-Trillot
* */
private void NextTurn()
{
if (PlayingNow == Piece.Color.White)
{
PlayingNow = Piece.Color.Black;
}
else
{
PlayingNow = Piece.Color.White;
}
}
public static Piece.Color OtherColor(Piece.Color pColor)
{
if (pColor.Equals(Piece.Color.WHITE))
{
return(Piece.Color.BLACK);
}
else
{
return(Piece.Color.WHITE);
}
}
public void ChangeCurrentColor()
{
if (aCurrentColor == Piece.Color.WHITE)
{
aCurrentColor = Piece.Color.BLACK;
}
else
{
aCurrentColor = Piece.Color.WHITE;
}
}
public void MovePiece(Coord coordPiece, Coord coordDestination, Piece.Color color)
{
if (GameBoard[coordDestination.x, coordDestination.y] != null && GameBoard[coordDestination.x, coordDestination.y].id == "\u2654" || GameBoard[coordDestination.x, coordDestination.y] != null &&
GameBoard[coordDestination.x, coordDestination.y].id == "\u265A")
{
Console.Write(color + " Win");
StartGame();
}
GameBoard[coordDestination.x, coordDestination.y] = GameBoard[coordPiece.x, coordPiece.y];
GameBoard[coordPiece.x, coordPiece.y] = null;
}
public Roi GetKing(Piece.Color color)
{
foreach (Piece p in GameBoard)
{
if (p != null && p.color == color && p.name == "Roi")
{
return((Roi)p);
}
}
return(null);
}
public void RemoveJumpedLastTurn(ChessBoard chessBoard, Piece.Color color)
{
for (int i = 0; i < chessBoard.GetBoard().Length; i++)
{
for (int j = 0; j < chessBoard.GetBoard().Length; j++)
{
if (chessBoard.GetBoard()[i, j].HasPiece() && chessBoard.GetBoard()[i, j].GetPiece().GetColor() == color)
{
if (chessBoard.GetBoard()[i, j].GetPiece().GetJumpedLastTurn())
{
chessBoard.GetBoard()[i, j].GetPiece().SetJumpedLastTurn(false);
}
}
}
}
}
public ChessBoardView(ChessBoard pBoard, PieceManipulator pPieceManipulator, Brush pWhiteSquareBrushes, Brush pBlackSquareBrushes)
{
aFirstPlayer = Piece.Color.WHITE;
aBoard = pBoard;
aSquaresView = new SquareView[8, 8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
aSquaresView[i, j] = new SquareView(aBoard.GetBoard()[i, j]);
}
}
aPieceManipulatorView = new PieceManipulatorView(pPieceManipulator);
aWhiteSquareBrushes = pWhiteSquareBrushes;
aBlackSquareBrushes = pBlackSquareBrushes;
Lines = Pens.Black;
}
/**
* Game()
*
* Constructeur de la classe.
* L'instanciation déclenche automatiquement le jeu.
*
* @author Axel Floquet-Trillot
* */
public Game()
{
//Création du plateau, Blancs pour le premier tour
GameBoard = new Piece[8, 8];
PlayingNow = Piece.Color.White;
FirstTurn = true;
//Initialisation des listes de menaces aux rois
WhiteMateThreats = new List <Coordinates>();
BlackMateThreats = new List <Coordinates>();
//Initialisation des listes de pièces mangées
EatenByBlack = new List <Piece>();
EatenByWhite = new List <Piece>();
StartGame();
}
public void PlayTurn(string joueur, Piece.Color color)
{
PrintBoard();
Console.Write("\n" + joueur + "\n");
Coord coordPieceToMove = AskPieceToMove(color);
List <Coord> coordListMove = AskMoveIntoAList(coordPieceToMove);
Coord coordDestination = ChooseWhereMovePiece(coordListMove);
if (coordDestination == null)
{
while (coordDestination == null)
{
coordDestination = ChooseWhereMovePiece(coordListMove);
}
}
MovePiece(coordPieceToMove, coordDestination, color);
}
public Player(Piece.Color c)
{
color = c;
isMyTurn = false;
username = color == Piece.Color.Black ? "Black" : "White";
}
public void SetCurrentColor(Piece.Color pColor)
{
aCurrentColor = pColor;
}
public void PlayTurn()
{
List <Coord> ValidMoves = new List <Coord>();
List <Piece> pieceToMustMove = new List <Piece>();
Piece validPiece;
Console.Write(" Tour: " + round);
if (round % 2 == 1)
{
Console.WriteLine(" - Manche Blanche");
colorRound = Piece.Color.white;
}
if (round % 2 == 0)
{
Console.WriteLine(" - Manche Noire");
colorRound = Piece.Color.black;
}
Console.Write("\n");
Roi king = GetKing(colorRound);
if (king.isEchec)
{
Console.Write(" Votre roi est en echec. Vous devez jouer une des pieces suivantes : ");
pieceToMustMove = IsPieceWhoCanDisableEchec(king.pieceMakeEchec, king.color);
if (pieceToMustMove != null)
{
pieceToMustMove.ForEach(delegate(Piece p)
{
Console.Write(" " + p.name + " ");
});
}
Console.Write("\n");
}
while (true)
{
Console.Write(" Quelle Piece Avancer ? ");
string pieceToMove = Console.ReadLine();
if (king.isEchec)
{
validPiece = IsValidPieceEchec(pieceToMove, pieceToMustMove);
}
else
{
validPiece = IsValidPiece(pieceToMove);
}
if (validPiece != null)
{
if (king.isEchec)
{
ValidMoves = validPiece.GetPossibleMovesWhenInEchec(GameBoard, validPiece.Coord, king);
}
else
{
ValidMoves = validPiece.GetPossibleMoves(GameBoard, validPiece.Coord);
}
if (validPiece.name.Contains("P"))
{
Pion pion = (Pion)validPiece;
pion.IsFirst = false;
}
if (ValidMoves != null)
{
Console.Write(" Mouvement Possible: ");
ValidMoves.ForEach(delegate(Coord c)
{
Console.Write(" " + c.x + "-" + c.y + " ");
});
Console.Write("\n");
Console.Write(" Deplacer cette piece ? [y/n] ");
string validPieceToMove = Console.ReadLine();
if (validPieceToMove == "y")
{
break;
}
}
else
{
Console.WriteLine(" Cette piece ne peut pas se deplacer. Reselectionnez en une !");
}
}
else
{
Console.WriteLine(" La piece selectionnee est invalide. Reselectionnez en une !");
}
}
while (true)
{
Console.Write(" Ou deplacer la piece ? Format: X-Y ");
string placeToMove = Console.ReadLine();
Coord validPlace = IsValidPlace(placeToMove, ValidMoves);
if (validPlace != null)
{
MovePiece(validPiece.Coord, validPlace);
validPiece.Coord = validPlace;
round++;
break;
}
else
{
Console.WriteLine(" Coordonnees invalides ! Reessayer !");
}
}
}
public Player(Piece.Color c, string Name)
{
color = c; name = Name;
}
public void SetFirstPlayer(Piece.Color color)
{
aFirstPlayer = color;
}
public Coord AskPieceToMove(Piece.Color color)
{
Console.Write("Please select the piece you want to move" + "\n");
Console.Write("[A..H]: ");
string X = Console.ReadLine();
int x = 0;
if (new string[]
{ "A", "a", "B", "b", "C", "c", "D", "d", "E", "e", "F", "f", "G", "g", "H", "h" }.Contains(X))
{
}
else
{
Console.Write("Hmmm..." + X + " Doesn't exist..\n");
AskPieceToMove(color);
}
switch (X)
{
case "A":
case "a":
x = 1;
break;
case "B":
case "b":
x = 2;
break;
case "C":
case "c":
x = 3;
break;
case "D":
case "d":
x = 4;
break;
case "E":
case "e":
x = 5;
break;
case "F":
case "f":
x = 6;
break;
case "G":
case "g":
x = 7;
break;
case "H":
case "h":
x = 8;
break;
}
Console.Write("\n" + "[1..8]:");
int y = int.Parse(Console.ReadLine());
if (y < 1 || y > 8)
{
Console.Write("Hmmm..." + y + " Doesn't exist..\n");
AskPieceToMove(color);
}
if (GameBoard[x, y].c != color)
{
Console.Write("Are you sure this is your piece ?\n");
AskPieceToMove(color);
}
Coord coord = new Coord(x, y);
return(coord);
}
