Ejemplo n.º 1
0
        internal bool EstTermine()
        {
            bool    blancExiste = false;
            bool    noirExiste  = false;
            PieceIA tmpPiece    = null;

            for (int j = Plateau.TAILLE - 1; j >= 0; j--)
            {
                for (int i = 0; i < Plateau.TAILLE; i++)
                {
                    tmpPiece = Grille[i, j];
                    if (tmpPiece == null)
                    {
                        continue;
                    }

                    if (tmpPiece.EstBlanc)
                    {
                        blancExiste = true;
                    }
                    else
                    {
                        noirExiste = true;
                    }

                    if (blancExiste && noirExiste)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Ejemplo n.º 2
0
        //aucun test de véricafivation
        internal void Effectuer(Mouvement mouv)
        {
            PieceIA piece   = Get(mouv.Depart);
            Coords  origine = mouv.Depart;

            Coords tmp = new Coords();

            origine = mouv.Depart;
            Coords direction;

            Grille[origine.X, origine.Y] = null;
            foreach (var coord in mouv.Sauts)
            {
                direction = (coord - origine).GetVraiUnitaire();
                tmp       = origine;
                do
                {
                    tmp += direction;
                    Grille[tmp.X, tmp.Y] = null;
                } while (tmp.X != coord.X);

                origine = coord;
            }
            //ici, origine vaut la derniere case du deplacement
            Grille[origine.X, origine.Y] = piece;
        }
Ejemplo n.º 3
0
        private bool EstMinimalementValide(PlateauIA plateau, Coords origine, Coords fin, Coords unitaire, ref int nbPrises, ref PieceIA sautee)
        {
            if (!Plateau.EstDansLePlateau(fin))
            {
                return(false);
            }

            bool    dejaPrise = false;
            var     tmp       = origine;
            PieceIA tmpPiece  = null;

            while (tmp != fin)//on se déplace en diagonale, pas besoin de tout comparer TODO:
            {
                tmp     += unitaire;
                tmpPiece = plateau.Get(tmp);
                if (tmpPiece != null)
                {
                    if (dejaPrise || tmpPiece.flag)
                    {
                        return(false);
                    }
                    else
                    {
                        dejaPrise = true;
                        sautee    = tmpPiece;
                    }
                    if (tmpPiece.EstBlanc == EstBlanc)
                    {
                        return(false);
                    }
                }
            }
            if (tmpPiece == null)
            {
                if (dejaPrise)
                {
                    nbPrises++;
                }
                return(true);
            }
            return(false);
        }
Ejemplo n.º 4
0
        private void GetMouvementsPossiblesRec(PlateauIA plateau, Stack <Tuple <int, Mouvement> > possibles, Mouvement coups, ref Coords origine, Coords directionOrigineDirecteur, int nbPrises = 0)
        {
            if (coups.Sauts.Count > 0)
            {
                possibles.Push(new Tuple <int, Mouvement>(nbPrises, coups));
            }

            Coords  tmpPos          = origine;
            PieceIA tmpPiece        = null;
            Coords  direction       = directionOrigineDirecteur;
            int     tmpPrises       = 0;
            bool    invalideUneFois = false;

            while (true)
            {
                tmpPos   += direction;
                tmpPrises = nbPrises;
                if (EstMinimalementValide(plateau, origine, tmpPos, direction, ref tmpPrises, ref tmpPiece))
                {
                    if (tmpPrises > nbPrises)
                    {
                        tmpPiece.flag = true;
                        var tmpCoups = new Mouvement(coups);
                        tmpCoups.Sauts.Enqueue(tmpPos);
                        GetMouvementsPossiblesRec(plateau, possibles, tmpCoups, ref tmpPos, direction, tmpPrises);
                        tmpPiece.flag = false;
                    }
                    else
                    {
                        var tmpCoups = new Mouvement(coups);
                        tmpCoups.Sauts.Enqueue(tmpPos);
                        possibles.Push(new Tuple <int, Mouvement>(nbPrises, tmpCoups));
                    }
                }
                else
                {
                    if (invalideUneFois)
                    {
                        invalideUneFois = false;
                        break;
                    }
                    invalideUneFois = true;
                }
            }
            if (directionOrigineDirecteur.GetVraiUnitaire() == DIAG1)
            {
                direction = DIAG2;
            }
            else
            {
                direction = DIAG1;
            }
            tmpPos = origine;
            while (true)
            {
                tmpPos   += direction;
                tmpPrises = nbPrises;
                if (EstMinimalementValide(plateau, origine, tmpPos, direction, ref tmpPrises, ref tmpPiece))
                {
                    if (tmpPrises > nbPrises)
                    {
                        var tmpCoups = new Mouvement(coups);
                        tmpCoups.Sauts.Enqueue(tmpPos);
                        tmpPiece.flag = true;
                        GetMouvementsPossiblesRec(plateau, possibles, tmpCoups, ref tmpPos, direction, tmpPrises);
                        tmpPiece.flag = false;
                    }
                    else if (coups.Sauts.Count == 0)
                    {
                        var tmpCoups = new Mouvement(coups);
                        tmpCoups.Sauts.Enqueue(tmpPos);
                        possibles.Push(new Tuple <int, Mouvement>(nbPrises, tmpCoups));
                    }
                }
                else
                {
                    if (invalideUneFois)
                    {
                        invalideUneFois = false;
                        break;
                    }
                    invalideUneFois = true;
                }
            }
            tmpPos = origine;
            while (true)
            {
                tmpPos   -= direction; // la difference est la
                tmpPrises = nbPrises;
                if (EstMinimalementValide(plateau, origine, tmpPos, -direction, ref tmpPrises, ref tmpPiece))
                {
                    if (tmpPrises > nbPrises)
                    {
                        var tmpCoups = new Mouvement(coups);
                        tmpCoups.Sauts.Enqueue(tmpPos);
                        tmpPiece.flag = true;
                        GetMouvementsPossiblesRec(plateau, possibles, tmpCoups, ref tmpPos, -direction, tmpPrises);
                        tmpPiece.flag = false;
                    }
                    else if (coups.Sauts.Count == 0)
                    {
                        var tmpCoups = new Mouvement(coups);
                        tmpCoups.Sauts.Enqueue(tmpPos);
                        possibles.Push(new Tuple <int, Mouvement>(nbPrises, tmpCoups));
                    }
                }
                else
                {
                    if (invalideUneFois)
                    {
                        invalideUneFois = false;
                        break;
                    }
                    invalideUneFois = true;
                }
            }
        }