public override bool Deplacer(Case destination)
{
// Positive is up, Negative is down
int horizontal_distance = this.position.Rangee - destination.Rangee;
// Positive is left, Negative is right
int vertical_distance = this.position.Colonne - destination.Colonne;
int starting_row_white = 6;
int starting_row_black = 1;
int colorMultiplier = joueur.couleur == CouleurCamp.Blanche ? 1 : -1;
bool destinationOccupied = destination.piece != null;
// Déplacement normal
if (horizontal_distance == 1 * colorMultiplier && vertical_distance == 0 &&
!destinationOccupied)
{
destination.Link(this);
this.position = destination;
enPassant = false;
return(true);
}
// Déplacemenent sur la position de départ
if (((joueur.couleur == CouleurCamp.Blanche && position.Rangee == starting_row_white) ||
(joueur.couleur == CouleurCamp.Noire && position.Rangee == starting_row_black)) &&
!destinationOccupied && !pieceSurLeChemin(destination))
{
if (horizontal_distance == 2 * colorMultiplier && vertical_distance == 0)
{
destination.Link(this);
this.position = destination;
enPassant = true;
return(true);
}
}
// Capture
if (destinationOccupied && destination.piece.joueur.couleur != joueur.couleur &&
horizontal_distance == 1 * colorMultiplier && Math.Abs(vertical_distance) == 1)
{
destination.Link(this);
this.position = destination;
enPassant = false;
return(true);
}
// Prise en passant
return(false);
}
public override bool Deplacer(Case destination)
{
var sauvePremierDeplacement = premierDeplacement;
if (!DeplacementValide(destination) ||
CaseBloquee(destination) ||
!position.CheminLibre(destination))
{
premierDeplacement = sauvePremierDeplacement;
return(false);
}
premierDeplacement = false;
if (DeplacementEnPassant(destination, true))
{
destination.Link(this);
}
else if (!DeplacementDiagonal(destination))
{
if (destination.piece != null)
{
return(false);
}
else
{
destination.Link(this);
}
}
else if (DeplacementDiagonal(destination) && destination.piece != null)
{
destination.Link(this);
}
else
{
return(false);
}
// Promotion
if (DetecterPromotion(destination))
{
Dame d = new Dame(joueur);
d.position = destination;
destination.piece = d;
position.echiquier.partie.vue
.ActualiserCase(destination.x, destination.y, d.info);
}
return(true);
}
public override bool Deplacer(Case destination)
{
// Positive is up, Negative is down
int horizontal_distance = this.position.Rangee - destination.Rangee;
// Positive is left, Negative is right
int vertical_distance = this.position.Colonne - destination.Colonne;
bool destinationOccupiedBySameColor = false;
if (destination.piece != null)
{
destinationOccupiedBySameColor = destination.piece.joueur.couleur == joueur.couleur;
}
bool movedOnlyOneTile = Math.Abs(vertical_distance) * Math.Abs(horizontal_distance) < 2;
if (movedOnlyOneTile && destination != position && !destinationOccupiedBySameColor)
{
destination.Link(this);
this.position = destination;
return(true);
}
return(false);
}
public override bool Deplacer(Case destination)
{
// Positive is up, Negative is down
int horizontal_distance = this.position.Rangee - destination.Rangee;
// Positive is left, Negative is right
int vertical_distance = this.position.Colonne - destination.Colonne;
bool destinationOccupiedBySameColor = false;
if (destination.piece != null)
{
destinationOccupiedBySameColor = destination.piece.joueur.couleur == joueur.couleur;
}
bool movingInDiagonal = Math.Abs(horizontal_distance) == Math.Abs(vertical_distance);
bool movingInOnlyOneDirection = horizontal_distance * vertical_distance == 0;
Console.WriteLine("Diag : " + movingInDiagonal.ToString() + ", same tile : " + (destination != position) + ", sameColor : " + destinationOccupiedBySameColor);
if ((movingInDiagonal || movingInOnlyOneDirection) && destination != position && !destinationOccupiedBySameColor && !pieceSurLeChemin(destination))
{
destination.Link(this);
this.position = destination;
return(true);
}
return(false);
}
public override bool Deplacer(Case destination)
{
// Positive is up, Negative is down
int horizontal_distance = this.position.Rangee - destination.Rangee;
// Positive is left, Negative is right
int vertical_distance = this.position.Colonne - destination.Colonne;
bool destinationOccupiedBySameColor = false;
if (destination.piece != null)
{
destinationOccupiedBySameColor = destination.piece.joueur.couleur == joueur.couleur;
}
bool movingInOnlyOneDirection = horizontal_distance * vertical_distance == 0;
if (movingInOnlyOneDirection && destination != position && !destinationOccupiedBySameColor && !pieceSurLeChemin(destination))
{
destination.Link(this);
this.position = destination;
return(true);
}
return(false);
}
public override bool Deplacer(Case destination)
{
if (IsMoveLegal(destination))
{
joueur.partie.canEp = false;
destination.Link(this);
return(true);
}
return(false);
}
public override bool Deplacer(Case destination)
{
if (IsMoveLegal(destination))
{
canCastle = false;
joueur.partie.canEp = false;
destination.Link(this);
return true;
}
return false;
}
public override bool Deplacer(Case destination)
{
if (CaseBloquee(destination) || !position.CheminLibre(destination))
{
return(false);
}
destination.Link(this);
return(true);
}
public override bool Deplacer(Case destination)
{
if (CaseBloquee(destination) ||
!DeplacementValide(destination))
{
return(false);
}
destination.Link(this);
return(true);
}
public override bool Deplacer(Case destination)
{
if (IsMoveLegal(destination))
{
destination.Link(this);
isFirstMove = false;
if (destination.row == 0 || destination.row == 7)
{
Promote();
}
return(true);
}
return(false);
}
public override bool Deplacer(Case destination)
{
if (CaseBloquee(destination) ||
!position.CheminLibre(destination))
{
return(false);
}
if (!TraiterPetitRoque(destination) &&
!TraiterGrandRoque(destination))
{
if (!DeplacementValide(destination))
{
return(false);
}
}
destination.Link(this);
return(true);
}
public override bool Deplacer(Case destination)
{
destination.Link(this);
return(true);
}
public void DeplacerPiece(int x_depart, int y_depart, int x_arrivee, int y_arrivee)
{
// case de départ
Case depart = echiquier.cases[x_depart, y_depart];
// case d'arrivée
Case destination = echiquier.cases[x_arrivee, y_arrivee];
// deplacer
bool ok = depart.piece.Deplacer(destination);
/* TEST */
//vue.ActualiserCase(x_depart, y_depart, null);
//vue.ActualiserCase(x_arrivee, y_arrivee, InfoPiece.RoiBlanc);
/* FIN TEST */
// changer d'état
if (ok)
{
// Roque
if (depart.piece.GetType() == typeof(Roi) && Math.Abs(depart.row - destination.row) == 2 && depart.col - destination.col == 0)
{
destination.Link(depart.piece);
destination.piece.position = destination;
depart.Unlink();
vue.ActualiserCase(destination.row, destination.col, destination.piece.info);
vue.ActualiserCase(depart.row, depart.col, null);
// Deplacement de la tour
Case tourDepart;
int oldRowTour;
int oldColTour = destination.col;
Case tourDestination;
int newRowTour;
int newColTour = destination.col;
if (destination.row - depart.row == 2)
{
oldRowTour = 7;
newRowTour = 5;
}
else
{
oldRowTour = 0;
newRowTour = 3;
}
tourDepart = echiquier.cases[oldRowTour, oldColTour];
tourDestination = echiquier.cases[newRowTour, newColTour];
tourDestination.Link(tourDepart.piece);
tourDestination.piece.position = tourDestination;
tourDepart.Unlink();
vue.ActualiserCase(tourDestination.row, tourDestination.col, tourDestination.piece.info);
vue.ActualiserCase(tourDepart.row, tourDepart.col, null);
}
// La prise en passant
if (depart.piece.GetType() == typeof(Pion) &&
Math.Abs(depart.row - destination.row) == 1 &&
Math.Abs(depart.col - destination.col) == 1)
{
Console.WriteLine("depart.row - destination.row = " + (depart.row - destination.row));
Console.WriteLine("depart.col - destination.col = " + (depart.col - destination.col));
if (depart.row - destination.row == -1)
{
piecesCapturees.Add(echiquier.cases[depart.row + 1, depart.col].piece.info);
vue.ActualiserCase(depart.row + 1, depart.col, null);
}
if (depart.row - destination.row == 1)
{
piecesCapturees.Add(echiquier.cases[depart.row - 1, depart.col].piece.info);
vue.ActualiserCase(depart.row - 1, depart.col, null);
}
destination.Link(depart.piece);
destination.piece.position = destination;
depart.Unlink();
vue.ActualiserCase(destination.row, destination.col, destination.piece.info);
vue.ActualiserCase(depart.row, depart.col, null);
}
else
{
// Actualiser Captures
if (destination.piece != null)
{
piecesCapturees.Add(destination.piece.info);
}
destination.Unlink();
destination.Link(depart.piece);
destination.piece.position = destination;
depart.Unlink();
vue.ActualiserCase(destination.row, destination.col, destination.piece.info);
vue.ActualiserCase(depart.row, depart.col, null);
}
vue.ActualiserCaptures(piecesCapturees);
ChangerEtat();
}
}
