示例#1
0
        public static int Main(string[] args)
        {
            #region Initialisation de la grille, des lettres du jeu, du dictionnaire et du solveur

                Console.SetWindowSize(80, 50);
                Console.Title = "Scrabble";
                Letters.createAlphabetRandom();
                try
                {
                    Algorythms.fillDico(@"..\..\dico_fr_sans_accent.txt", Structures.dictionary, Structures.sizeWords);
                }
                catch
                {
                    Console.WriteLine("                        _______________\n");
                    Console.WriteLine("                      > S C R A B B L E <");
                    Console.WriteLine("                        _______________\n");
                    Exception ex = new Exception("Impossible de charger le dictionnaire ! Appuyez sur une touche pour quitter.");
                    Console.WriteLine(ex.Message);
                    Console.ReadLine();
                    Environment.Exit(0);
                }

                Letters.createLettersValue();

                Structures.box[,] grille = new Structures.box[15, 15];
                Grille.initialiserGrille(grille);
                Structures.wordScrabble[] Words = new Structures.wordScrabble[10];
                for (int i = 0; i < Words.Length; i++)
                    Words[i].letters = new char[15];

                int[] scores = new int[10];

                #endregion

                #region Initialisation des joueurs

                Console.WriteLine("                        _______________\n");
                Console.WriteLine("                      > S C R A B B L E <");
                Console.WriteLine("                        _______________\n");
                Console.WriteLine("Veuillez saisir le nombre de joueurs, 4 au maximum.");
                int nbPlayers;
                bool convertedNbPlayers = int.TryParse(Console.ReadLine(), out nbPlayers);
                while (nbPlayers <= 0 || nbPlayers > 4 || !convertedNbPlayers)
                {
                    Console.WriteLine("\nNombre de joueurs invalides. Veuillez saisir le nombre de joueurs, 4 au maximum.");
                    convertedNbPlayers = int.TryParse(Console.ReadLine(), out nbPlayers);
                }

                for (int i = 0; i < nbPlayers; i++)
                {
                    Console.WriteLine("\nTapez le nom du joueur " + (i + 1) + ".");
                    Structures.game_players[i].nom = Console.ReadLine();
                    while (Structures.game_players[i].nom.Length < 1)
                    {
                        Console.WriteLine("\nNom vide ! Tapez le nom du joueur " + (i + 1) + ".");
                        Structures.game_players[i].nom = Console.ReadLine();
                    }

                    Console.WriteLine("\nDe quel type est ce joueur ?  1 pour humain et 0 pour ordinateur.");
                    int type;
                    bool typeBool = int.TryParse(Console.ReadLine(), out type);
                    while (type < 0 || type > 1 || !typeBool)
                    {
                        Console.WriteLine("\nType invalide ! De quel type est ce joueur ?  1 pour humain et 0 pour ordinateur.");
                        typeBool = int.TryParse(Console.ReadLine(), out type);
                    }
                    if (type == 1)
                    {
                        Structures.game_players[i].ia = false;
                        Console.WriteLine("\nVoulez-vous jouer avec l'aide du solveur ? 1 pour oui et 0 pour non.");
                        int solveur;
                        bool solveurBool = int.TryParse(Console.ReadLine(), out solveur);
                        while (solveur < 0 || solveur > 1 || !typeBool)
                        {
                            Console.WriteLine("\nChoix non valide !Voulez-vous jouer avec l'aide du solveur ? 1 pour oui et 0 pour non.");
                            solveurBool = int.TryParse(Console.ReadLine(), out solveur);
                        }
                        if (solveur == 1)
                            Structures.game_players[i].solveur = true;
                        else
                            Structures.game_players[i].solveur = false;

                    }
                    else
                    {
                        Structures.game_players[i].ia = true;
                        Structures.game_players[i].solveur = false;
                    }

                    Structures.game_players[i].score = 0;
                    Structures.game_players[i].player_letters = new char[7];
                }

                Console.Clear();

                #endregion

                #region Tirage des lettres pour chaque joueur

                for (int i = 0; i < nbPlayers; i++)
                {
                    for (int j = 0; j < 7; j++)
                    {
                        Structures.game_players[i].player_letters[j] = Structures.game_letters[Structures.letterUsed];
                        Structures.letterUsed++;
                    }
                }

                #endregion

                #region Jeu en cours

                //démarrage du jeu
                int letterDispo = 1;
                bool firstTour = true;
                Grille.afficherGrille(grille);

                while (letterDispo == 1)
                {
                    for (int joueur = 0; joueur < nbPlayers; joueur++)
                    {
                        //affichage des lettres et du score du joueur actuel
                        Console.WriteLine("____________________________________________\n");
                        Console.WriteLine("                 " + Structures.game_players[joueur].nom.ToUpper() + "\n");
                        Console.WriteLine("Score : {0} \n", Structures.game_players[joueur].score);
                        Console.Write("Lettres disponibles : ");
                        for (int i = 0; i < 7; i++)
                        {
                            Console.Write("{0}{1}", Structures.game_players[joueur].player_letters[i], (i != 6 ? ',' : '.'));
                        }

                        Console.WriteLine("\n____________________________________________\n");
                        Console.WriteLine("Appuyez sur 'Entrée' pour continuer");
                        Console.ReadLine();

                        //joueur IA
                        if (Structures.game_players[joueur].ia)
                        {
                            Console.WriteLine("                 AU TOUR DE " + Structures.game_players[joueur].nom.ToUpper() + " DE JOUER !\n");

                            //premier tour du joueur IA
                            if (firstTour)
                            {
                                Console.WriteLine("Patientez, le joueur " + Structures.game_players[joueur].nom + " place son mot...");
                                Grille.findBestFirstWord(grille, Structures.game_players[joueur].player_letters, Words, 1, scores);
                                letterDispo = Letters.takeLetter(ref Structures.game_players[joueur], grille, Words[0]);
                                Grille.addWordGrille(grille, Words[0].letters, Words[0].l, Words[0].position, Words[0].x, Words[0].y);
                                Structures.game_players[joueur].score += scores[0];
                                firstTour = false;
                            }

                            //tours suivants du joueur IA
                            else
                            {
                                Console.WriteLine("Patientez, le joueur " + Structures.game_players[joueur].nom + " place son mot...");
                                Algorythms.searchWord(grille, Structures.game_players[joueur].player_letters, 1, Words, scores);
                                letterDispo = Letters.takeLetter(ref Structures.game_players[joueur], grille, Words[0]);
                                Grille.addWordGrille(grille, Words[0].letters, Words[0].l, Words[0].position, Words[0].x, Words[0].y);
                                Structures.game_players[joueur].score += scores[0];
                            }
                        }

                        //joueur non IA
                        else
                        {
                            Console.WriteLine("                 AU TOUR DE " + Structures.game_players[joueur].nom.ToUpper() + " DE JOUER !\n");

                            //premier tour du joueur humain
                            if (firstTour)
                            {
                                firstTour = false;

                                //Solutions proposées au joueur humain pour le premier tour
                                if (Structures.game_players[joueur].solveur)
                                {
                                    Grille.findBestFirstWord(grille, Structures.game_players[joueur].player_letters, Words, 10, scores);
                                    Console.WriteLine("                        _______\n");
                                    Console.WriteLine("                        SOLVEUR");
                                    Console.WriteLine("                        _______\n");

                                    for (int i = 0; i < 10; i++)
                                    {
                                        if (scores[i] >= 1)
                                        {
                                            Console.Write("{0} : Mot: ", i);
                                            for (int j = 0; j < Words[i].l; j++)
                                            {
                                                Console.Write("{0}", Words[i].letters[j]);
                                            }
                                            string pos;
                                            if (Words[i].position)
                                                pos = "HORIZONTAL";
                                            else
                                                pos = "VERTICAL";
                                            Console.WriteLine(" ligne:{0}, colonne:{1}, position:{2}, points:{3} \n", Words[i].x, Words[i].y, pos, scores[i]);
                                        }
                                    }
                                    Console.WriteLine("_____________________________________________");
                                }

                                bool ok = false;
                                while (!ok)
                                {
                                    string car;
                                    Console.WriteLine("\n                 QUE VOULEZ-VOUS FAIRE ?");
                                    Console.WriteLine("_____________________________________________\n");
                                    if (Structures.game_players[joueur].solveur)
                                        Console.WriteLine("Taper un numéro parmi les solutions proposées puis 'Entrée' pour placer un mot.");
                                    Console.WriteLine("Taper U puis 'Entrée' pour placer votre propre mot");
                                    Console.WriteLine("Taper P puis 'Entrée' pour passer votre tour");
                                    Console.WriteLine("Taper C puis 'Entrée pour changer des lettres et passer votre tour");
                                    car = Console.ReadLine();
                                    while (car.Length == 0 || car.Length > 1)
                                    {
                                        Console.WriteLine("        -----> Votre choix n'est pas valide ! <------");
                                        Console.WriteLine("\nChoisissez le mot à placer, taper U pour poser votre propre mot\ntaper P pour passer votre tour\nou taper C pour changer de lettres");
                                        car = Console.ReadLine();
                                    }

                                    char c = char.Parse(car);

                                    if (c >= '0' && c <= '9' && Structures.game_players[joueur].solveur)
                                    {
                                        int l = c - '0';
                                        letterDispo = Letters.takeLetter(ref Structures.game_players[joueur], grille, Words[l]);//ref
                                        Grille.addWordGrille(grille, Words[l].letters, Words[l].l, Words[l].position, Words[l].x, Words[l].y);
                                        Structures.game_players[joueur].score += scores[l];
                                        ok = true;
                                    }

                                    else if (c == 'p' || c == 'P')
                                    {
                                        firstTour = true;
                                        ok=true;
                                    }
                                    else if (c == 'c' || c == 'C')
                                    {
                                        Console.WriteLine("Combien de lettres voulez vous changer ? (7 au maximum)");
                                        int nbLettersToChange;
                                        bool convertedNbLetters = int.TryParse(Console.ReadLine(), out nbLettersToChange);
                                        while (nbLettersToChange <= 0 || nbLettersToChange > 7 || !convertedNbLetters)
                                        {
                                            Console.WriteLine("\nNombre de lettres à changer invalides. Veuillez saisir le nombre de lettres à changer, 7 au maximum.");
                                            convertedNbLetters = int.TryParse(Console.ReadLine(), out nbLettersToChange);
                                        }
                                        Letters.changeLetter(ref Structures.game_players[joueur], nbLettersToChange);
                                        firstTour = false;

                                        if (nbPlayers == 1)
                                            firstTour = true;

                                        ok = true;
                                    }
                                    else if (c == 'u' || c == 'U')
                                    {
                                        Console.WriteLine("\nQuel mot souhaitez-vous placez?");
                                        string w = Console.ReadLine();
                                        while (w.Length < 2)
                                        {
                                            Console.WriteLine("\nLe premier mot doit posséder 2 lettres. Quel mot souhaitez-vous placez ?");
                                            w = Console.ReadLine();
                                        }
                                        w = w.ToUpper();

                                        Structures.wordScrabble tmp;
                                        tmp.letters = new char[15];

                                        for (int i = 0; i < w.Length; i++)
                                        {
                                            tmp.letters[i] = char.ToUpper(w[i]);
                                        }

                                        tmp.x = 7;
                                        tmp.y = 7;
                                        tmp.position = true;
                                        tmp.l = w.Length;

                                        if (!Algorythms.hasLettersFirstWord(w, Structures.game_players[joueur].player_letters))
                                        {
                                            Console.WriteLine("       ----> Dommage ! <---- \nLettres invalides, mot rattaché à aucun autre ou posé sur une case déjà utilisée!\n");
                                            ok = true;
                                        }
                                        else
                                        {
                                            int v = Algorythms.valueOfWord(tmp, grille);
                                            if (v == -1)
                                            {
                                                Console.WriteLine("       ----> Dommage ! <---- \nMot invalide sur la grille !\n");
                                                ok = true;
                                            }
                                            else
                                            {
                                                letterDispo = Letters.takeLetter(ref Structures.game_players[joueur], grille, tmp);
                                                Grille.addWordGrille(grille, tmp.letters, tmp.l, tmp.position, tmp.x, tmp.y);
                                                Structures.game_players[joueur].score += v;
                                                ok = true;
                                            }
                                        }
                                    }
                                }
                            }

                            //tours suivants du joueur humain
                            else
                            {
                               //Solutions proposées au joueur humain pour les tours suivants
                                if (Structures.game_players[joueur].solveur)
                                {
                                    Algorythms.searchWord(grille, Structures.game_players[joueur].player_letters, 10, Words, scores);
                                    Console.WriteLine("                        _______\n");
                                    Console.WriteLine("                        SOLVEUR");
                                    Console.WriteLine("                        _______\n");

                                    for (int i = 0; i < 10; i++)
                                    {
                                        if (scores[i] >= 1)
                                        {
                                            Console.Write("{0}: Mot: ", i);
                                            for (int j = 0; j < Words[i].l; j++)
                                            {
                                                Console.Write("{0}", Words[i].letters[j]);
                                            }
                                            string pos;
                                            if (Words[i].position)
                                                pos = "HORIZONTAL";
                                            else
                                                pos = "VERTICAL";
                                            Console.WriteLine(" ligne:{0}, colonne:{1}, position:{2},points:{3} \n", Words[i].x, Words[i].y, pos, scores[i]);
                                        }
                                    }
                                    Console.WriteLine("_____________________________________________\n");
                                }

                                bool ok = false;
                                while (!ok)
                                {
                                    string car;
                                    Console.WriteLine("\n                 QUE VOULEZ-VOUS FAIRE ?");
                                    Console.WriteLine("_____________________________________________\n");
                                    if(Structures.game_players[joueur].solveur)
                                        Console.WriteLine("Taper un numéro parmi les solutions proposées puis 'Entrée' pour placer un mot.");
                                    Console.WriteLine("Taper U puis 'Entrée' pour placer votre propre mot");
                                    Console.WriteLine("Taper P puis 'Entrée' pour passer votre tour");
                                    Console.WriteLine("Taper C puis 'Entrée pour changer des lettres et passer votre tour");
                                    car = Console.ReadLine();
                                    while (car.Length == 0 || car.Length > 1)
                                    {
                                        Console.WriteLine("        -----> Votre choix n'est pas valide ! <------");
                                        Console.WriteLine("\nChoisissez le mot à placer, taper U pour poser votre propre mot\ntaper P pour passer votre tour\nou taper C pour changer de lettres");
                                        car = Console.ReadLine();
                                    }

                                    char c = char.Parse(car);

                                    if (c >= '0' && c <= '9' && Structures.game_players[joueur].solveur)
                                    {
                                        int l = c - '0';
                                        letterDispo = Letters.takeLetter(ref Structures.game_players[joueur], grille, Words[l]);
                                        Grille.addWordGrille(grille, Words[l].letters, Words[l].l, Words[l].position, Words[l].x, Words[l].y);
                                        Structures.game_players[joueur].score += scores[l];
                                        ok = true;
                                    }

                                    else if (c == 'p' || c == 'P')
                                        ok=true;

                                    else if (c=='c' || c=='C')
                                    {
                                        Console.WriteLine("Combien de lettres voulez vous changer ? (7 au maximum)");
                                        int nbLettersToChange;
                                        bool convertedNbLetters = int.TryParse(Console.ReadLine(), out nbLettersToChange);
                                        while (nbLettersToChange <= 0 || nbLettersToChange > 7 || !convertedNbLetters)
                                        {
                                            Console.WriteLine("\nNombre de lettres à changer invalides. Veuillez saisir le nombre de lettres à changer, 7 au maximum.");
                                            convertedNbLetters = int.TryParse(Console.ReadLine(), out nbLettersToChange);
                                        }
                                        Letters.changeLetter(ref Structures.game_players[joueur], nbLettersToChange);
                                        ok = true;
                                    }

                                    else if (c == 'u' || c == 'U')
                                    {
                                        Console.WriteLine("\nQuel mot souhaitez-vous placez?");
                                        string w = Console.ReadLine();
                                        w = w.ToUpper();

                                        Console.WriteLine("\nA quelle ligne ? (de 0 à 14, le point d'origine est en haut gauche)");
                                        int x;
                                        bool convertedX = int.TryParse(Console.ReadLine(), out x);
                                        while (x < 0 || x > 14 || !convertedX)
                                        {
                                            Console.WriteLine("\nLigne invalide. A quelle ligne ?");
                                            convertedX = int.TryParse(Console.ReadLine(), out x);
                                        }

                                        Console.WriteLine("\nA quelle colonne ? (de 0 à 14, le point d'origine est en haut à gauche)");
                                        int y;
                                        bool convertedY = int.TryParse(Console.ReadLine(), out y);
                                        while (y < 0 || y > 14 || !convertedY)
                                        {
                                            Console.WriteLine("\nColonne invalide. A quelle colonne ?");
                                            convertedY = int.TryParse(Console.ReadLine(), out y);
                                        }

                                        Console.WriteLine("\nDans quel sens? (horizontal=1, vertical=0)");
                                        int sens;
                                        bool sensBool = int.TryParse(Console.ReadLine(), out sens);
                                        while (sens < 0 || sens > 1 || !sensBool)
                                        {
                                            Console.WriteLine("\nSens invalide. Dans quel sens ?");
                                            sensBool = int.TryParse(Console.ReadLine(), out sens);
                                        }
                                        Structures.wordScrabble tmp;
                                        tmp.letters = new char[15];

                                        for (int i = 0; i < w.Length; i++)
                                        {
                                            tmp.letters[i] = char.ToUpper(w[i]);
                                        }

                                        tmp.x = x;
                                        tmp.y = y;
                                        if (sens == 1)
                                            tmp.position = true;
                                        else
                                            tmp.position = false;
                                        tmp.l = w.Length;

                                        if (!Algorythms.hasLetters(grille, Structures.game_players[joueur].player_letters, tmp))
                                        {
                                            Console.WriteLine("       ----> Dommage ! <---- \nLettres insuffisantes, mot rattaché à aucun autre ou posé sur une case déjà utilisée !\n");
                                            ok = true;
                                        }
                                        else
                                        {
                                            int v = Algorythms.valueOfWord(tmp, grille);
                                            if (v == -1)
                                            {
                                                Console.WriteLine("       ----> Dommage ! <---- \nMot invalide sur la grille !\n");
                                                ok = true;
                                            }
                                            else
                                            {
                                                letterDispo = Letters.takeLetter(ref Structures.game_players[joueur], grille, tmp);
                                                Grille.addWordGrille(grille, tmp.letters, tmp.l, tmp.position, tmp.x, tmp.y);
                                                Structures.game_players[joueur].score += v;
                                                ok = true;
                                            }
                                        }
                                    }
                                }
                            }
                        }

                        //à chaque fin de tour on clear et affiche la nouvelle grille.
                        Console.Clear();
                        Grille.afficherGrille(grille);

                        //fin de la partie
                        if (letterDispo == 0)
                        {
                            Console.WriteLine("\n               -----> Plus de lettres dans le jeu ! <-----");

                            Console.WriteLine("                        ___________\n");
                            Console.WriteLine("                        SCORE FINAL");
                            Console.WriteLine("                        ___________\n");

                            //score de chaque joueur en fin de partie
                            for (int i = 0; i < Structures.game_players.Length; i++)
                            {
                                if (Structures.game_players[i].score > 0)
                                    Console.WriteLine("Le joueur " + Structures.game_players[i].nom + " a obtenu le score de " + Structures.game_players[i].score + "\n");
                            }
                            Console.ReadLine();
                        }
                    }

                #endregion

            }

            return 0;
        }
示例#2
0
        /// <summary>
        /// initialise la grille
        /// </summary>
        /// <param name="grille">grille de jeu</param>
        public static void initialiserGrille(Structures.box[,] grille)
        {
            Structures.box tmpBox = new Structures.box();
            Structures.token tmpTok = new Structures.token();
            tmpTok.letter = 'a';
            tmpTok.value = 0;
            tmpBox.bonus = 0;
            tmpBox.tok = tmpTok;

            for (int i = 0; i < 15; i++)
            {
                for (int j = 0; j < 15; j++)
                {
                    grille[i, j] = tmpBox;

                }
            }

            // création des bonus

            //RED
            for (int i = 0; i < 15; i += 7)
            {
                for (int j = 0; j < 15; j += 7)
                {
                    grille[i, j].bonus = 2;
                }
            }

            //MAG
            for (int i = 1; i < 5; i++)
            {
                grille[i, i].bonus = 1;
                grille[14 - i, 14 - i].bonus = 1;
                grille[i, 14 - i].bonus = 1;
                grille[14 - i, i].bonus = 1;
            }
            grille[7, 7].bonus = 1;

            //CYN
            for (int i = 0; i < Structures.nbCyans; i++)
            {
                grille[Structures.cyanBoxes[i, 0], Structures.cyanBoxes[i, 1]].bonus = 3;
            }

            //BLUE
            for (int i = 0; i < Structures.nbBlues; i++)
            {
                grille[Structures.blueBoxes[i, 0], Structures.blueBoxes[i, 1]].bonus = 4;
            }
        }
示例#3
0
        /// <summary>
        /// cherche les n meilleurs mots possibles à jouer suivant les lettres du joueurs et les lettres sur le plateau de jeu
        /// </summary>
        /// <param name="Grille">grille de jeu</param>
        /// <param name="letters">lettres du joueur</param>
        /// <param name="n">nombre de meilleurs mots à chercher</param>
        /// <param name="Words">tableau de wordScrabble</param>
        /// <param name="scores">tableau des scores pour chaque mot</param>
        public static void searchWord(Structures.box [,] Grille,char [] letters,int n, Structures.wordScrabble [] Words, int [] scores)
        {
            int m;
            int v;
            for(int i=0;i<n;i++)
                scores[i] = 0;
            for(int i = 0; i < 15; i++)
            {
                Structures.box [] line = new Structures.box [15];
                Structures.box [] column = new Structures.box [15];

                for(int j = 0;j < 15;j++)
                {
                    line[j] = Grille[i,j];
                    column[j] = Grille[j,i];
                }
                Structures.wordScrabble [] WordsTmp = new Structures.wordScrabble [10000];
                m =searchWordByLine(line,letters, true, i,WordsTmp);

                for(int k=0;k<m;k++)
                {
                    v=valueOfWord(WordsTmp[k],Grille);

                    if(v != -1)
                    {
                        for(int j=0;j<n;j++)
                        {
                            if(scores[j] == -1)
                            {
                                Words[j] = WordsTmp[k];
                                scores[j] = v;
                                break;
                            }
                            else if(scores[j] < v)
                            {
                                Structures.wordScrabble wordNow;
                                Structures.wordScrabble wordNext;
                                int scoreNow;
                                int scoreNext;
                                wordNow = WordsTmp[k];
                                scoreNow = v;

                                for(int h=j; h<n;h++)
                                {
                                    wordNext = Words[h];
                                    scoreNext = scores[h];
                                    Words[h] = wordNow;
                                    scores[h] = scoreNow;
                                    wordNow = wordNext;
                                    scoreNow = scoreNext;
                                }
                                break;
                            }
                        }
                    }
                }

                m=searchWordByLine(column,letters, false, i,WordsTmp);

                for(int k=0;k<m;k++)
                {
                    v=valueOfWord(WordsTmp[k],Grille);

                    if(v != -1)
                    {
                        for(int j=0;j<n;j++)
                        {
                            if(scores[j] == -1)
                            {
                                Words[j] = WordsTmp[k];
                                scores[j] = v;
                                break;
                            }

                            else if(scores[j] < v)
                            {
                                Structures.wordScrabble wordNow;
                                Structures.wordScrabble wordNext;
                                int scoreNow;
                                int scoreNext;
                                wordNow = WordsTmp[k];
                                scoreNow = v;
                                for(int h=j; h<n;h++)
                                {
                                    wordNext = Words[h];
                                    scoreNext = scores[h];
                                    Words[h] = wordNow;
                                    scores[h] = scoreNow;
                                    wordNow = wordNext;
                                    scoreNow = scoreNext;
                                }
                                break;
                            }
                        }
                    }
                }
            }
        }