Ejemplo n.º 1
0
        private static bool PeutAvoirDesElementsIdentiquesEnHautEtEnBasGagnant(Coordonnee uneCoordonnee, int nbrElementGagnant)
        {
            int nbrCaseRestantEnBas  = (nbrElementGagnant - 1) - uneCoordonnee.Y;
            int nbrCaseRestantEnHaut = uneCoordonnee.Y - 0;

            return((nbrCaseRestantEnBas >= 1) && (nbrCaseRestantEnHaut >= 1));
        }
Ejemplo n.º 2
0
        private static bool PeutAvoirDesElementsIdentiquesAGaucheEtDroiteGagnant(Coordonnee uneCoordonnee, int nbrElementGagnant)
        {
            int nbrCaseRestanteADroite = (nbrElementGagnant - 1) - uneCoordonnee.X;
            int nbrCaseRestanteAGauche = uneCoordonnee.X - 0;

            return((nbrCaseRestanteADroite >= 1) && (nbrCaseRestanteAGauche >= 1));
        }
Ejemplo n.º 3
0
        private static bool PeutAvoirDesElementsIdentiquesSeSuivantEnHautOuEnBas(Coordonnee uneCoordonnee, int nbrElementGagnant)
        {
            int nbrCaseRestanteEnHaut = uneCoordonnee.Y;
            int nbrCaseRestanteEnBas  = Math.Abs(uneCoordonnee.Y - (nbrElementGagnant - 1));

            return((nbrCaseRestanteEnBas == (nbrElementGagnant - 1)) || (nbrCaseRestanteEnHaut == (nbrElementGagnant - 1)));
        }
Ejemplo n.º 4
0
        private int GetNbrElementsTrouvesIdentiquesHorizontale(Coordonnee uneCoordonnee, IElement unPion, int nbrElementGagnant)
        {
            int nbrElementTrouve = 0;

            if (PeutAllerAGauche(uneCoordonnee, nbrElementGagnant))
            {
                nbrElementTrouve = nbrElementTrouve + GetNbrELementsIdentiqueAGauche(uneCoordonnee, unPion, nbrElementGagnant);
            }

            if ((nbrElementTrouve < (nbrElementGagnant - 1)) && PeutAllerADroite(uneCoordonnee, nbrElementGagnant))
            {
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesADroite(uneCoordonnee, unPion, nbrElementGagnant);
            }

            if ((nbrElementTrouve < (nbrElementGagnant - 1)) && PeutAvoirDesElementsIdentiquesAGaucheEtDroiteGagnant(uneCoordonnee, nbrElementGagnant))
            {
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesADroite(uneCoordonnee, unPion, nbrElementGagnant);
                nbrElementTrouve = nbrElementTrouve + GetNbrELementsIdentiqueAGauche(uneCoordonnee, unPion, nbrElementGagnant);
            }


            nbrElementTrouve++;//Plus l'élément lui même coché

            return(nbrElementTrouve);
        }
Ejemplo n.º 5
0
 public CaseMorpion(Coordonnee laCoordonnee)
 {
     _maCoordonnee     = laCoordonnee;
     _value            = new Pion("");
     _id               = MethodesGlobales.ConvertirCoordonneEnIdCase(laCoordonnee);
     _maRepresentation = new ControlCaseMorpion(MethodesGlobales.ConvertirCoordonneEnIdCase(laCoordonnee));
 }
Ejemplo n.º 6
0
        private int GetNbrElementsIdentiquesEnBasAGauche(Coordonnee uneCoordonnee, Pion unPion, int p_nbrElementGagnant)
        {
            int nbrElementTrouve = 0;

            int nbrMaxCount = p_nbrElementGagnant;

            int  iCompteur          = 0;
            bool aTrouveeUnMemePion = true;

            while (aTrouveeUnMemePion && (uneCoordonnee.X - iCompteur < nbrMaxCount) && (uneCoordonnee.Y + iCompteur < nbrMaxCount))
            {
                if (_mesCases[ConvertIdCase(uneCoordonnee.X - iCompteur, uneCoordonnee.Y + iCompteur)].GetElement().Valeur().Equals(unPion.Valeur()))
                {
                    nbrElementTrouve++;
                }
                else
                {
                    aTrouveeUnMemePion = false;
                }

                iCompteur++;
            }

            return(nbrElementTrouve - 1);
        }
Ejemplo n.º 7
0
        private static bool PeutAvoirDesElementsIdentiquesSeSuivantAGaucheOuADroite(Coordonnee uneCoordonnee, int nbrElementGagnant)
        {
            int nbrCaseRestanteAGauche = uneCoordonnee.X;
            int nbrCaseRestanteADroite = (nbrElementGagnant - 1) - uneCoordonnee.X;

            return((nbrCaseRestanteAGauche == (nbrElementGagnant - 1)) || (nbrCaseRestanteADroite == (nbrElementGagnant - 1)));
        }
Ejemplo n.º 8
0
 public CaseMorpion(Coordonnee laCoordonnee, IRepresentationCaseMorpion uneRepresentationCaseMorpion) : base()
 {
     _maCoordonnee     = laCoordonnee;
     _value            = new Pion("");
     _id               = MethodesGlobales.ConvertirCoordonneEnIdCase(laCoordonnee);
     _maRepresentation = uneRepresentationCaseMorpion;
 }
Ejemplo n.º 9
0
 public void PoserElement(Coordonnee cetteCoordonnee, Pion unPion)
 {
     if (_mesCases.ContainsKey(ConvertIdCase(cetteCoordonnee.X, cetteCoordonnee.Y)))
     {
         if (!_mesCases[ConvertIdCase(cetteCoordonnee.X, cetteCoordonnee.Y)].EstCoche())
         {
             _mesCases[ConvertIdCase(cetteCoordonnee.X, cetteCoordonnee.Y)].RecevoirElement(unPion);
         }
     }
 }
Ejemplo n.º 10
0
        private static bool CaseAyantBordureCommeVoisinDeCase(Coordonnee uneCoordonnee, int p_nbrElementGagnant)
        {
            int nbrCaseEnHaut  = uneCoordonnee.Y - 0;
            int nbrCaseAGauche = uneCoordonnee.X - 0;

            int nbrCaseEnBas   = (p_nbrElementGagnant - 1) - uneCoordonnee.Y;
            int nbrCaseADroite = (p_nbrElementGagnant - 1) - uneCoordonnee.X;

            return((nbrCaseEnHaut >= 1) && (nbrCaseAGauche >= 1) && (nbrCaseEnBas >= 1) && (nbrCaseADroite >= 1));
        }
Ejemplo n.º 11
0
        public bool CaseLibre(Coordonnee cetteCoordonnee)
        {
            bool rep = false;

            if (_mesCases.ContainsKey(ConvertIdCase(cetteCoordonnee.X, cetteCoordonnee.Y)))
            {
                if (!_mesCases[ConvertIdCase(cetteCoordonnee.X, cetteCoordonnee.Y)].EstCoche())
                {
                    rep = true;
                }
            }

            return(rep);
        }
Ejemplo n.º 12
0
        private bool VerfierSiJoueurGagneHorizontalement(Coordonnee uneCoordonnee, IElement unPion, int nbrElementGagnant)
        {
            if (PeutGagneHorizontalement(uneCoordonnee, nbrElementGagnant))
            {
                int nbrElementTrouve = GetNbrElementsTrouvesIdentiquesHorizontale(uneCoordonnee, unPion, nbrElementGagnant);

                if (nbrElementTrouve == nbrElementGagnant)
                {
                    return(true);
                }
            }

            return(false);
        }
Ejemplo n.º 13
0
        private bool VerifierSiJoueurGagneVerticalement(Coordonnee uneCoordonnee, Pion unPion, int p_nbrElementGagnant)
        {
            if (PeutGagneVerticalement(uneCoordonnee, p_nbrElementGagnant))
            {
                int nbrElementTrouve = GetNbrElementsTrouvesIdentiquesVerticale(uneCoordonnee, unPion, p_nbrElementGagnant);

                if (nbrElementTrouve == p_nbrElementGagnant)
                {
                    return(true);
                }
            }

            return(false);
        }
Ejemplo n.º 14
0
        private int GetNbrElementsTrouvesIdentiquesDiagonalement(Coordonnee uneCoordonnee, Pion unPion, int p_nbrElementGagnant)
        {
            int nbrElementTrouve = 0;

            if (PeutAllerEnHautADroite(uneCoordonnee, p_nbrElementGagnant))
            {
                nbrElementTrouve = 0;
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnHautADroite(uneCoordonnee, unPion, p_nbrElementGagnant);
            }

            if (PeutAllerEnHautAGauche(uneCoordonnee, p_nbrElementGagnant))
            {
                nbrElementTrouve = 0;
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnHautAGauche(uneCoordonnee, unPion, p_nbrElementGagnant);
            }

            if (PeutAllerEnBasADroite(uneCoordonnee, p_nbrElementGagnant))
            {
                nbrElementTrouve = 0;
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnBasADroite(uneCoordonnee, unPion, p_nbrElementGagnant);
            }

            if (PeutAllerEnBasAGauche(uneCoordonnee, p_nbrElementGagnant))
            {
                nbrElementTrouve = 0;
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnBasAGauche(uneCoordonnee, unPion, p_nbrElementGagnant);
            }

            if (PeutAllerEnHautADroiteEtEnBasAGauche(uneCoordonnee, p_nbrElementGagnant))
            {
                nbrElementTrouve = 0;
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnHautADroite(uneCoordonnee, unPion, p_nbrElementGagnant);
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnBasAGauche(uneCoordonnee, unPion, p_nbrElementGagnant);
            }

            if (PeutAllerEnHautAGaucheEtEnBasADroite(uneCoordonnee, p_nbrElementGagnant))
            {
                nbrElementTrouve = 0;
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnHautAGauche(uneCoordonnee, unPion, p_nbrElementGagnant);
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnBasADroite(uneCoordonnee, unPion, p_nbrElementGagnant);
            }

            nbrElementTrouve++;

            return(nbrElementTrouve);
        }
Ejemplo n.º 15
0
 public void AnnulerPoseElement(Coordonnee uneCoordonnee, System.Drawing.Image image)
 {
     if (_mesCases.ContainsKey(ConvertIdCase(uneCoordonnee.X, uneCoordonnee.Y)))
     {
         if (Properties.Resources.image_O.Equals(MethodesGlobales.GetSauvegardeAvantDerniereCoche()))
         {
             _mesCases[ConvertIdCase(uneCoordonnee.X, uneCoordonnee.Y)].AnnulerElement(new Pion("O"), MethodesGlobales.GetSauvegardeAvantDerniereCoche());
         }
         else if (Properties.Resources.image_X.Equals(MethodesGlobales.GetSauvegardeAvantDerniereCoche()))
         {
             _mesCases[ConvertIdCase(uneCoordonnee.X, uneCoordonnee.Y)].AnnulerElement(new Pion("X"), MethodesGlobales.GetSauvegardeAvantDerniereCoche());
         }
         else
         {
             _mesCases[ConvertIdCase(uneCoordonnee.X, uneCoordonnee.Y)].AnnulerElement(new Pion(""), MethodesGlobales.GetSauvegardeAvantDerniereCoche());
         }
     }
 }
Ejemplo n.º 16
0
        public Plateau(int taillePlateau)
        {
            _mesCases = new Dictionary <string, ICase>();


            for (int y = 0; y < taillePlateau; y++)
            {
                for (int x = 0; x < taillePlateau; x++)
                {
                    Coordonnee  uneCoordonnee = new Coordonnee(x, y);
                    CaseMorpion uneCase       = new CaseMorpion(uneCoordonnee);

                    ControlCaseMorpion unControl = (ControlCaseMorpion)uneCase.GetRepresentation();
                    unControl.Name = _mesCases.Count.ToString();
                    _mesCases.Add(ConvertIdCase(x, y), uneCase);
                }
            }
        }
Ejemplo n.º 17
0
        public bool VerifierSiJoueurGagne(Coordonnee uneCoordonnee, Pion unPion, int nbrElementGagnantMax)
        {
            if (VerfierSiJoueurGagneHorizontalement(uneCoordonnee, unPion, nbrElementGagnantMax))
            {
                return(true);
            }

            if (VerifierSiJoueurGagneVerticalement(uneCoordonnee, unPion, nbrElementGagnantMax))
            {
                return(true);
            }

            if (VerifierSiJoueurGagneDiagonalement(uneCoordonnee, unPion, nbrElementGagnantMax))
            {
                return(true);
            }

            return(false);
        }
Ejemplo n.º 18
0
        private int GetNbrElementsTrouvesIdentiquesVerticale(Coordonnee uneCoordonnee, IElement unPion, int nbrElementGagnant)
        {
            int nbrElementTrouve = 0;

            if (PeutAllerEnHaut(uneCoordonnee, nbrElementGagnant))
            {
                nbrElementTrouve = nbrElementTrouve + GetNbrELementsIdentiqueEnHaut(uneCoordonnee, unPion, nbrElementGagnant);
            }

            if ((nbrElementTrouve < (nbrElementGagnant - 1)) && PeutAllerEnBas(uneCoordonnee, nbrElementGagnant))
            {
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnBas(uneCoordonnee, unPion, nbrElementGagnant);
            }

            if ((nbrElementTrouve < (nbrElementGagnant - 1)) && PeutAvoirDesElementsIdentiquesEnHautEtEnBasGagnant(uneCoordonnee, nbrElementGagnant))
            {
                nbrElementTrouve = nbrElementTrouve + GetNbrELementsIdentiqueEnHaut(uneCoordonnee, unPion, nbrElementGagnant);
                nbrElementTrouve = nbrElementTrouve + GetNbrElementsIdentiquesEnBas(uneCoordonnee, unPion, nbrElementGagnant);
            }

            nbrElementTrouve++;//Plus l'élément lui même coché

            return(nbrElementTrouve);
        }
Ejemplo n.º 19
0
        private int GetNbrElementsIdentiquesEnHaut(Coordonnee uneCoordonnee, IElement unPion, int nbrElementGagnant)
        {
            int nbrElementTrouve = 0;
            int nbrMaxCount      = nbrElementGagnant * -1;

            int  iCompteur          = uneCoordonnee.Y;
            bool aTrouveeUnMemePion = true;

            while (aTrouveeUnMemePion && (uneCoordonnee.X > nbrMaxCount) && (uneCoordonnee.Y + iCompteur > nbrMaxCount))
            {
                if (_mesCases[ConvertIdCase(uneCoordonnee.X, uneCoordonnee.Y + iCompteur)].GetElement().Valeur().Equals(unPion.Valeur()))
                {
                    nbrElementTrouve++;
                }
                else
                {
                    aTrouveeUnMemePion = false;
                }

                iCompteur--;
            }

            return(nbrElementTrouve - 1);
        }
Ejemplo n.º 20
0
        private int GetNbrELementsIdentiqueAGauche(Coordonnee uneCoordonnee, IElement unPion, int nbrElementGagnant)
        {
            int nbrElementTrouve = 0;
            int nbrMaxCountX     = (nbrElementGagnant) * -1;

            int  iCompteur          = 0;
            bool aTrouveeUnMemePion = true;

            while (aTrouveeUnMemePion && (uneCoordonnee.X + iCompteur > -1))
            {
                if (_mesCases[ConvertIdCase(uneCoordonnee.X + iCompteur, uneCoordonnee.Y)].GetElement().Valeur().Equals(unPion.Valeur()))
                {
                    nbrElementTrouve++;
                }
                else
                {
                    aTrouveeUnMemePion = false;
                }

                iCompteur--;
            }

            return(nbrElementTrouve - 1);
        }
Ejemplo n.º 21
0
 private static bool PeutAllerEnHaut(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(uneCoordonnee.Y == (nbrElementGagnant - 1));
 }
Ejemplo n.º 22
0
 private bool PeutAllerEnHautADroiteEtEnBasAGauche(Coordonnee uneCoordonnee, int p_nbrElementGagnant)
 {
     return(CaseAyantBordureCommeVoisinDeCase(uneCoordonnee, p_nbrElementGagnant));
 }
Ejemplo n.º 23
0
 private static bool PeutGagneVerticalement(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(PeutAvoirDesElementsIdentiquesSeSuivantEnHautOuEnBas(uneCoordonnee, nbrElementGagnant) || PeutAvoirDesElementsIdentiquesEnHautEtEnBasGagnant(uneCoordonnee, nbrElementGagnant));
 }
Ejemplo n.º 24
0
 private static string ConvertIdCaseVarY(Coordonnee uneCoordonnee, int i)
 {
     return(String.Format("X{0}Y{1}", uneCoordonnee.X, uneCoordonnee.Y + i));
 }
Ejemplo n.º 25
0
 private static bool PeutAllerAGauche(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return((uneCoordonnee.X - 0) == (nbrElementGagnant - 1));
 }
Ejemplo n.º 26
0
 private static bool PeutGagneHorizontalement(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(PeutAvoirDesElementsIdentiquesSeSuivantAGaucheOuADroite(uneCoordonnee, nbrElementGagnant) || PeutAvoirDesElementsIdentiquesAGaucheEtDroiteGagnant(uneCoordonnee, nbrElementGagnant));
 }
Ejemplo n.º 27
0
 private static bool PeutAllerEnHautADroite(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(PeutAllerEnHaut(uneCoordonnee, nbrElementGagnant) && PeutAllerADroite(uneCoordonnee, nbrElementGagnant));
 }
Ejemplo n.º 28
0
 private static bool PeutAllerEnBasAGauche(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(PeutAllerEnBas(uneCoordonnee, nbrElementGagnant) && PeutAllerAGauche(uneCoordonnee, nbrElementGagnant));
 }
Ejemplo n.º 29
0
 private static bool PeutAllerEnBas(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(((nbrElementGagnant - 1) - uneCoordonnee.Y) == (nbrElementGagnant - 1));
 }
Ejemplo n.º 30
0
 private static bool PeutAllerADroite(Coordonnee uneCoordonnee, int nbrElementGagnant)
 {
     return(((nbrElementGagnant - 1) - uneCoordonnee.X) == (nbrElementGagnant - 1));
 }