예제 #1
0
        public bool CanBeAttacked(InfoPiece infos, Case depart, Case arrivee)
        {
            #region Directions
            //row, col
            Tuple <int, int> hautGauche = new Tuple <int, int>(-1, -1);
            Tuple <int, int> haut       = new Tuple <int, int>(-1, 0);
            Tuple <int, int> hautDroite = new Tuple <int, int>(-1, 1);
            Tuple <int, int> droite     = new Tuple <int, int>(0, 1);
            Tuple <int, int> basDroite  = new Tuple <int, int>(1, 1);
            Tuple <int, int> bas        = new Tuple <int, int>(1, 0);
            Tuple <int, int> basGauche  = new Tuple <int, int>(1, -1);
            Tuple <int, int> gauche     = new Tuple <int, int>(0, -1);

            Tuple <int, int> cavalier1 = new Tuple <int, int>(1, 2);
            Tuple <int, int> cavalier2 = new Tuple <int, int>(1, -2);
            Tuple <int, int> cavalier3 = new Tuple <int, int>(2, 1);
            Tuple <int, int> cavalier4 = new Tuple <int, int>(2, -1);
            Tuple <int, int> cavalier5 = new Tuple <int, int>(-1, 2);
            Tuple <int, int> cavalier6 = new Tuple <int, int>(-1, -2);
            Tuple <int, int> cavalier7 = new Tuple <int, int>(-2, 1);
            Tuple <int, int> cavalier8 = new Tuple <int, int>(-2, -1);

            List <Tuple <int, int> > directions = new List <Tuple <int, int> >();
            directions.Add(hautGauche); directions.Add(cavalier1);
            directions.Add(haut);       directions.Add(cavalier2);
            directions.Add(hautDroite); directions.Add(cavalier3);
            directions.Add(droite);     directions.Add(cavalier4);
            directions.Add(basDroite);  directions.Add(cavalier5);
            directions.Add(bas);        directions.Add(cavalier6);
            directions.Add(basGauche);  directions.Add(cavalier7);
            directions.Add(gauche);     directions.Add(cavalier8);
            #endregion

            int row = this.position.row;
            int col = this.position.col;

            //Si c'est le roi qui a bouger, prendre en compte la nouvelle pos
            if (infos.type == TypePiece.Roi)
            {
                row = arrivee.row;
                col = arrivee.col;
            }

            //Pour chaque direction
            foreach (Tuple <int, int> dir in directions)
            {
                //Slide
                int newRow = row;
                int newCol = col;
                while (true)
                {
                    newRow += dir.Item1;
                    newCol += dir.Item2;
                    //Si hors plateau, passer à la direction suivante
                    if (newRow < 0 || newRow > 7 || newCol < 0 || newCol > 7)
                    {
                        break;
                    }
                    //On récupère la case à tester et la piece sur cette case
                    Case  cSlide = this.joueur.partie.echiquier.cases[newRow, newCol];
                    Piece p      = cSlide.piece;
                    //Si vide ou ancienne pos et pas nouvelle pos, continuer a glisser,
                    //On considére l'ancienne case comme vide et la nouvelle comme remplis
                    if ((p == null && ((cSlide != arrivee)) || (cSlide == depart)))
                    {
                        if (dir.Item1 == 2 ||
                            dir.Item1 == -2 ||
                            dir.Item2 == 2 ||
                            dir.Item2 == -2)
                        {
                            break; //Si c'est une position de canasson, on ne glisse pas
                        }
                        continue;  //On passe à la suivante
                    }
                    //Si allié ou case d'arrivée, passer à la direction suivante
                    //On considere la nouvelle case comme occupé par un allié
                    if ((cSlide == arrivee) || (p != null && p.info.couleur == this.joueur.couleur))
                    {
                        break;
                    }
                    //Sinon ennemi, regarder le type pour voir s'il peut se déplacer dans cette direction
                    else
                    {
                        TypePiece pieceType = p.info.type;
                        //Si oui, return true
                        if (dir.Item1 == 2 || dir.Item1 == -2 || dir.Item2 == 2 || dir.Item2 == -2)
                        { // Si c'est une dir de canasson,
                            if (pieceType == TypePiece.Cavalier)
                            {
                                return(true);                                 //et un canasson, le roi peut être attaqué
                            }
                            //continue; //Si c'en est pas un, c'est safe
                        }
                        else if (pieceType == TypePiece.Dame)
                        {
                            return(true); //Peu importe la direction ou la distance
                        }
                        else if (pieceType == TypePiece.Roi)
                        {                                      //Si c'est un roi
                            if (Math.Abs(newRow - row) <= 1 && //Distance horizontal <= 1 et
                                Math.Abs(newCol - col) <= 1)   //Distance vertical <= 1
                            {
                                return(true);
                            }
                        }
                        else if (pieceType == TypePiece.Fou)
                        {
                            if (dir.Item1 != 0 && dir.Item2 != 0)
                            {
                                return(true);
                            }
                        }
                        else if (pieceType == TypePiece.Tour)       //Si c'est une tour
                        {
                            if (dir.Item1 == 0 && dir.Item2 != 1 || //Horizontal
                                dir.Item1 != 1 && dir.Item2 == 0)   //Vertical
                            {
                                return(true);
                            }
                        }
                        //Si c'est un pion
                        else if (pieceType == TypePiece.Pion)
                        {
                            if (p.info.couleur == CouleurCamp.Blanche) //De couleur blanche
                            {
                                //Une case en dessous et une colonne à côté
                                if (newRow == row + 1 && (newCol == col + 1 || newCol == col - 1))
                                {
                                    return(true);
                                }
                            }
                            else //De couleur noir
                            {
                                //Une case au dessous et une colonne à côté
                                if (newRow == row - 1 && (newCol == col + 1 || newCol == col - 1))
                                {
                                    return(true);
                                }
                            }
                        }
                        //Si non, passer à la direction suivante
                        break;
                    }
                }
            }
            return(false);
        }
예제 #2
0
        public override bool Deplacer(Case destination)
        {
            destination.Link(this);

            return(true);
        }
예제 #3
0
        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();
            }
        }
예제 #4
0
 public bool DeplacementSurLaCouleurInverse(Case destination)
 {
     return(destination.piece != null && destination.piece.joueur.couleur != this.joueur.couleur);
 }
예제 #5
0
 public bool DeplacementSurLaMemeCouleur(Case destination)
 {
     return(destination.piece != null && destination.piece.joueur.couleur == this.joueur.couleur);
 }
예제 #6
0
 public abstract bool Deplacer(Case destination);