Пример #1
0
        public bool DeplacerPiece(int x_depart, int y_depart, int x_arrivee, int y_arrivee, bool forceMove)
        {
            // case de départ
            Case depart = echiquier.Cases[x_depart, y_depart];

            // Case d'arrivée
            Case destination = echiquier.Cases[x_arrivee, y_arrivee];

            // Pièce de départ
            Piece piece = depart.linkedPiece;
            Piece specialPiece;

            if (depart == destination || (!CanMove(depart, destination, out specialPiece)))
            {
                return(false);
            }

            piece.moves++;

            // Check Promotion
            if (destination.NumLigne == 0 && piece.info.couleur == CouleurCamp.Blanche ||
                destination.NumLigne == 7 && piece.info.couleur == CouleurCamp.Noire)
            {
                Upgrade upgradeDial = new Upgrade
                {
                    StartPosition = System.Windows.Forms.FormStartPosition.CenterParent
                };
                upgradeDial.ShowDialog();
                piece          = ((Pion)piece).Promouvoir(upgradeDial.choosenPiece);
                piece.position = destination;
            }
            if (specialPiece != null)
            {
                DeplacerPiece(specialPiece.numColonne,
                              specialPiece.numLigne,
                              specialPiece.numColonne + ((destination.NumColonne - specialPiece.numColonne) * 2),
                              specialPiece.numLigne, true);
            }

            if (destination.linkedPiece != null)
            {
                TakePiece(destination.linkedPiece);
            }

            // Actualisation des cases
            vue.ActualiserCase(x_depart, y_depart, null);
            vue.ActualiserCase(x_arrivee, y_arrivee, piece.info);

            // Changement d'état des cases
            destination.Link(piece);
            depart.Unlink(piece);


            bool  echec;
            bool  mat;
            Piece roi;

            // Vérification de l'echec et du mat adverse
            if (status == StatusPartie.TraitBlancs)
            {
                roi = noirs.pieces.Find(x => x.info.type == TypePiece.Roi);
            }
            else
            {
                roi = blancs.pieces.Find(x => x.info.type == TypePiece.Roi);
            }

            echec = CheckDanger(CaseFromPiece(roi), roi.info.couleur);
            mat   = echec && AvailableMoves(roi).Count == 0;

            ChangerEtat(echec, mat);

            return(true);
        }
Пример #2
0
        private bool CheckPath(Piece piece, Case destination)
        {
            if (piece.info.type == TypePiece.Cavalier)
            {
                return(true);
            }

            if (piece.position.NumColonne == destination.NumColonne)
            {
                int min = Math.Min(piece.position.NumLigne, destination.NumLigne);
                int max = Math.Max(piece.position.NumLigne, destination.NumLigne);
                for (int i = min + 1; i < max; i++)
                {
                    Piece linkedPiece = echiquier.Cases[piece.position.NumColonne, i].linkedPiece;
                    if (linkedPiece != null && !linkedPiece.ignoreInCheckPath)
                    {
                        if (!echiquier.Cases[piece.position.NumColonne, i].linkedPiece.ignoreInCheckPath)
                        {
                            return(false);
                        }
                    }
                }
            }
            else if (piece.position.NumLigne == destination.NumLigne)
            {
                int min = Math.Min(piece.position.NumColonne, destination.NumColonne);
                int max = Math.Max(piece.position.NumColonne, destination.NumColonne);
                for (int i = min + 1; i < max; i++)
                {
                    Piece linkedPiece = echiquier.Cases[i, piece.position.NumLigne].linkedPiece;
                    if (linkedPiece != null && !linkedPiece.ignoreInCheckPath)
                    {
                        return(false);
                    }
                }
            }
            else if (piece.position.NumColonne != destination.NumColonne &&
                     piece.position.NumLigne != destination.NumLigne)
            {
                int difCol  = 1;
                int difLine = 1;

                if (destination.NumLigne < piece.position.NumLigne)
                {
                    difLine = -1;
                }

                if (destination.NumColonne < piece.position.NumColonne)
                {
                    difCol = -1;
                }

                int distanceX = Math.Abs(destination.NumColonne - piece.position.NumColonne);
                int distanceY = Math.Abs(destination.NumLigne - piece.position.NumLigne);

                for (int i = 1; i < distanceX; i++)
                {
                    if (echiquier.Cases[piece.position.NumColonne + difCol * i, piece.position.NumLigne + difLine * i].linkedPiece != null)
                    {
                        return(false);
                    }
                }
            }
            else
            {
                return(false);
            }

            return(true);
        }
Пример #3
0
        public bool CanMove(Case depart, Case destination, out Piece specialPiece)
        {
            // Init special piece
            specialPiece = null;
            // Piece de départ
            Piece piece = depart.linkedPiece;

            // En cas de coup spécial
            bool isSpecialMove = false;

            if (piece == null)
            {
                return(false);
            }

            #region Prises spéciales
            // Cas du pion (Prise en passant)
            if (piece.info.type == TypePiece.Pion)
            {
                // Prise en passant
                if (Math.Abs(destination.NumColonne - piece.numColonne) == 1 && Math.Abs(destination.NumLigne - piece.numLigne) == 1)
                {
                    Pion enpassantTarget = null;

                    int lineoffset = 0;
                    if (destination.NumLigne == 2 && piece.info.couleur == CouleurCamp.Blanche)
                    {
                        lineoffset = 1;
                    }
                    else if (destination.NumLigne == 5 && piece.info.couleur == CouleurCamp.Noire)
                    {
                        lineoffset = -1;
                    }

                    if (echiquier.Cases[destination.NumColonne, destination.NumLigne + lineoffset].linkedPiece != null)
                    {
                        if (typeof(Pion) == echiquier.Cases[destination.NumColonne, destination.NumLigne + lineoffset].linkedPiece.GetType())
                        {
                            enpassantTarget = (Pion)echiquier.Cases[destination.NumColonne, destination.NumLigne + lineoffset].linkedPiece;
                        }

                        if (enpassantTarget != null && enpassantTarget.moves == 1)
                        {
                            destination.linkedPiece = enpassantTarget;
                            isSpecialMove           = true;
                        }
                    }
                }
            }
            else if (piece.info.type == TypePiece.Roi && piece.moves == 0 && destination.linkedPiece == null &&
                     (destination.NumLigne == 0 || destination.NumLigne == 7))
            {
                specialPiece = piece.joueur.pieces.Find(x => x.info.type == TypePiece.Tour &&
                                                        x.moves == 0 &&
                                                        Math.Abs(x.numColonne - destination.NumColonne) == 1);
            }

            #endregion

            // Vérification des obstacles et des types de mouvements
            if (!piece.Deplacer(destination) && !isSpecialMove && specialPiece == null || !CheckPath(piece, destination))
            {
                return(false);
            }

            return(true);
        }