Exemplo n.º 1
0
        private void NouvelleReine(Pieces A)
        {
            Pieces nouvellePiece = PièceA.PromoteQueen();

            ListeDesPièces.Add(nouvellePiece);

            ListeDesPièces.Remove(PièceA);
        }
Exemplo n.º 2
0
        private void ResetPièces(Pieces A)
        {
            PièceA.Deplacer(CaseA.Centre);
            Compteur--;


            ResetCouleur();
        }
Exemplo n.º 3
0
        private void EstValidePionMange(Cases A, Cases B)
        {
            Vector3 déplacement = (B.Centre - A.Centre);

            if (!PièceA.EstValidePion(déplacement))
            {
                ResetPièces(PièceA, PièceB);
            }
        }
Exemplo n.º 4
0
        private void GèrerRook()
        {
            bool r = true;

            for (float i = 0; i <= 1; i += 0.5f)
            {
                //ON VÉRIFIE SI LE ROI PASSE PAR UNE CASE SUR LAQUELLE IL EST ÉCHEC LORSQU'IL ESSAIE DE ROQUER
                PièceA.Deplacer(CaseA.Centre + i * (CaseB.Centre - CaseA.Centre));
                if (EstEnEchec(PièceA.Couleur))
                {
                    r = false;
                }
            }
            bool aBouger = false;

            foreach (Pieces c in ListeDesPièces.FindAll(x => x.Nom == "/rook" && x.Couleur == PièceA.Couleur && x.EstPremierMove == true))
            {
                if (PièceA.EstPremierMove == true && r == true)
                // ON VÉRIFIE QUE LA TOUR ET LE ROI SONT À LEUR PREMIER DÉPLACEMENT
                {
                    if (c.Position == PièceA.Position + new Vector3(0, 0, Partie.LONGUEUR_CASE))
                    {
                        //SI LE ROI SE SITUE À LA BONNE DISTANCE D'UNE DES TOURS, ON FAIT LE DÉPLACEMENT
                        c.Deplacer(CaseA.Centre + new Vector3(0, 0, Partie.LONGUEUR_CASE));
                        aBouger = true;
                        PièceA.EstPremierMove = false;
                        ResetCouleur();
                    }

                    if (c.Position == PièceA.Position + new Vector3(0, 0, -2 * Partie.LONGUEUR_CASE))
                    {
                        //ON VÉRIFIE LE ROQUE DE VERS L'AUTRE SENS
                        c.Deplacer(CaseA.Centre + new Vector3(0, 0, -Partie.LONGUEUR_CASE));
                        aBouger = true;
                        PièceA.EstPremierMove = false;
                        ResetCouleur();
                    }
                }
            }
            if (aBouger == false)
            {
                //SI LE ROQUE EST INVALIDE, ON RESET LE ROI ET ON LUI REDONNE SON PREMIER DÉPLACEMENT
                ResetPièces(PièceA);
                PièceA.EstPremierMove = true;
            }
        }
Exemplo n.º 5
0
        private void GérerDéplacement()
        {
            if (GestionInput.EstNouveauClicGauche())
            {
                foreach (Cases o in ListeDesCases)
                {
                    //ON PROJETE LES VECTOR3 POUR OBTERNIR DES COORDONNÉES ÉCRAN

                    Vector3 HG = Game.GraphicsDevice.Viewport.Project(o.HG, CaméraJeu.Projection, this.CaméraJeu.Vue, Matrix.Identity);

                    Vector3 HD = Game.GraphicsDevice.Viewport.Project(o.HD, this.CaméraJeu.Projection, this.CaméraJeu.Vue, Matrix.Identity);

                    Vector3 BG = Game.GraphicsDevice.Viewport.Project(o.BG, this.CaméraJeu.Projection, this.CaméraJeu.Vue, Matrix.Identity);

                    Vector3 BD = Game.GraphicsDevice.Viewport.Project(o.BD, this.CaméraJeu.Projection, this.CaméraJeu.Vue, Matrix.Identity);


                    //ON CRÉE LES RECTANGLES DE COLLISIONS DES CASES
                    int       height = 0;
                    int       width  = 0;
                    Rectangle zone   = new Rectangle(0, 0, 0, 0);
                    if (Couleur == BLACK)
                    {
                        height = (int)(HD.Y - HG.Y);
                        width  = (int)(BG.X - HG.X);
                        zone   = new Rectangle((int)HG.X, (int)HG.Y, width, height);
                    }
                    else
                    {
                        height = (int)(HG.Y - HD.Y);
                        width  = (int)(HG.X - BG.X);
                        zone   = new Rectangle((int)BG.X, (int)HD.Y, width, height);
                    }



                    Point PosSouris = GestionInput.GetPositionSouris();


                    float k = Compteur;
                    if (zone.Contains(PosSouris))
                    {
                        //COLLISION ENTRE SOURIS ET CASE

                        if (CaseA != CaseB)
                        {
                            VérifierChangementCouleur(o);
                        }
                        if (CaseA == null)
                        {
                            CaseA = o;
                            VérifierChangementCouleur(o);
                        }
                        else
                        {
                            //LES DEUX CASES NE SONT PAS NULLES
                            CaseB = o;



                            foreach (Pieces a in ListeDesPièces.ToList())
                            {
                                if (CaseA != null && CaseB != null)
                                {
                                    //ON ENREGISTRE LA POSITION INITIALE DES PIÈCES
                                    SetÉtat();

                                    foreach (Pieces b in ListeDesPièces)
                                    {
                                        if (EstPropriétaire(b.Position, CaseB.Centre))
                                        {
                                            //ON TROUVE LA PIÈCE SE TROUVANT SUR caseB
                                            PièceB = b;
                                        }
                                    }
                                    if (EstPropriétaire(a.Position, CaseA.Centre))
                                    {
                                        //ON TROUVE LA PIÈCE SUR LA caseA ET ON VÉRIFIE SI ELLE RESPECTE LOGIQUE ET NESAUTEPAS
                                        if (a.Couleur == Couleur)
                                        {
                                            if (a.LogiqueDéplacement(new Vector2((CaseB.Centre.Z - CaseA.Centre.Z), (CaseB.Centre.X - CaseA.Centre.X))) && NeSautePas(CaseA.Centre, CaseB.Centre))
                                            {
                                                Compteur++;
                                                PièceA = a;


                                                if (PièceB == null)
                                                {
                                                    //ON PASSE ICI SI IL N'Y A PAS DE pièceB (DÉPLACEMENT SANS MANGER)
                                                    ResetCouleur();
                                                    PièceA.Deplacer(CaseB.Centre);

                                                    if (PièceA.Nom == "/pawn")
                                                    {
                                                        //ON VÉRIFIE LE CAS DU DÉPLACEMENT DU PION SANS MANGER
                                                        if (EstValidePionSeul(CaseA, CaseB))
                                                        {
                                                            PièceA.Deplacer(CaseA.Centre);
                                                            Compteur--;

                                                            ResetCouleur();
                                                        }
                                                        else
                                                        {
                                                            //ON VÉRIFIE SI LE PION EST AUX BORNES (PROMOTION)
                                                            if (EstAuBorne(PièceA.Couleur, CaseB))
                                                            {
                                                                NouvelleReine(PièceA);
                                                            }
                                                        }
                                                    }
                                                    if (PièceA.Nom == "/king")
                                                    {
                                                        //ON VÉRIFIE SI LE JOUEUR ESSAIE DE ROQUER
                                                        if (Math.Abs(CaseB.Centre.Z - CaseA.Centre.Z) > Partie.LONGUEUR_CASE && (!EstEnEchec(PièceA.Couleur)))
                                                        {
                                                            GèrerRook();
                                                        }
                                                    }


                                                    if (!EstPropriétaire(PièceA.Position, CaseA.Centre))
                                                    {
                                                        // SI pièceA A BOUGÉ, ON VÉRIFIE SI LE JOUEUR SE MET LUI-MÊME EN ÉCHEC
                                                        if (EstEnEchec(Couleur))
                                                        {
                                                            //ON REMET LA PIÈCE À SA POSITION INITIALE CAR LE MOUVEMENT EST INVALIDE (SE MET EN ÉCHEC)
                                                            PièceA.Deplacer(CaseA.Centre);
                                                            Compteur--;

                                                            ResetCouleur();
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    if (PièceA.Couleur != PièceB.Couleur)
                                                    {
                                                        //ON PASSE ICI SI LA pièceA VEUT MANGER LA pièceB
                                                        PièceB.Sortir(NbSortiesBlanc, NbSortiesNoir);


                                                        PièceA.Deplacer(CaseB.Centre);
                                                        ResetCouleur();

                                                        if (PièceA.Nom == "/pawn")
                                                        {
                                                            //ON VÉRIFIE LE CAS UNIQUE DU PION QUI MANGE UNE PIÈCE
                                                            Vector3 déplacement = (CaseB.Centre - CaseA.Centre);
                                                            if (!PièceA.EstValidePion(déplacement))
                                                            {
                                                                //ON RESET LES PIÈCES SI LE DÉPLACEMENT DU PION EST INVALIDE
                                                                ResetPièces(PièceA, PièceB);
                                                            }
                                                            else
                                                            {
                                                                if (EstAuBorne(PièceA.Couleur, CaseB))
                                                                {
                                                                    //ON PROMOTE LE PION SI IL EST AUX BORNES
                                                                    NouvelleReine(PièceA);
                                                                }
                                                            }
                                                        }

                                                        if (PièceA.Nom == "/king")
                                                        {
                                                            //IMPOSSIBLE DE ROQUER LORSQU'ON MANGE UNE PIÈCE, ON VÉRIFIE QUE LE JOUEUR N'ESSAIE PAS DE ROQUER
                                                            if (Math.Abs(CaseB.Centre.Z - CaseA.Centre.Z) > Partie.LONGUEUR_CASE)
                                                            {
                                                                ResetPièces(PièceA, PièceB);
                                                            }
                                                        }



                                                        if (EstEnEchec(Couleur))
                                                        {
                                                            //ON RESET LES PIÈCES SI LE JOUEUR S'EST MIS EN ÉCHEC
                                                            ResetPièces(PièceA, PièceB);
                                                        }
                                                        else
                                                        {
                                                            //ON MODIFIE LA POSITION DE SORTIE PUISQU'UNE PIÈCE EST SORTIE SI ON PASSE ICI
                                                            if (PièceB.Couleur == "White")
                                                            {
                                                                NbSortiesBlanc += 1;
                                                            }
                                                            else
                                                            {
                                                                NbSortiesNoir += 1;
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        //ON RESET LA PIÈCE CAR LE JOEUEUR A TENTÉ DE MANGER UNE PIÈCE DE LA MAUVAISE COULEUR

                                                        Compteur--;
                                                        ResetCouleur();
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                ResetCouleur();
                                            }
                                        }
                                        else
                                        {
                                            //ON UTILISE LA pièceB comme pièceA CAR LE JOUEUR A CLICKÉ SUR DEUX PIÈCES DE SA COULEUR
                                            ResetCouleur();
                                            VérifierChangementCouleur(CaseB);
                                            PièceA = PièceB;
                                            PièceB = null;
                                            CaseA  = CaseB;
                                            CaseB  = null;
                                        }
                                    }
                                    if (a == ListeDesPièces[NbPiece - 1])
                                    {
                                        //LE JOUEUR A PRIS UNE CASE VIDE COMME caseA, ON MET DONC LA caseB COMME ÉTANT caseA
                                        ResetCouleur();
                                        if (CaseB != null)
                                        {
                                            VérifierChangementCouleur(CaseB);
                                        }
                                        PièceA = PièceB;
                                        PièceB = null;
                                        CaseA  = CaseB;
                                        CaseB  = null;
                                    }



                                    foreach (Pieces g in ListeDesPièces.FindAll(x => x.Nom == "/rook" || x.Nom == "/king" || x.Nom == "/pawn"))
                                    {
                                        //POUR LES PIÈCES QUI DOIVENT SAVOIR SI ELLES SONT À LEUR PREMIER DÉPLACEMENT, ON VÉRIFIE SI ELLES ONT BOUGÉ
                                        if (g.Position != g.PosIni)
                                        {
                                            g.EstPremierMove = false;
                                        }
                                    }
                                }
                            }

                            float p = Compteur;
                            if (k != p)
                            {
                                //ON VÉRIFIE À L'AIDE DU COMPTEUR SI LE COUP A ÉTÉ JOUÉ, ON FAIT TOURNER LA CAMÉRA ET ON JOUE LE SON DE DÉPLACEMENT

                                CaméraJeu.Compteur = 0;
                                Chess_Hit_Sound.Play();
                            }
                            //ON VÉRIFIE SI IL FAUT JOUER LES SONS ÉCHEC/ÉCHEC ET MAT
                            JouerSons();
                        }
                    }
                }
            }
        }