Bonjour !

J'ai programmé un morpion en console, je sais que le code va surement être trop long ou pas bien organisé car je suis extrêmement novice. 

Toujours est-il que mon morpion ne peut se jouer qu'à deux, il ne possède pas la possibilité de jouer contre l'ordinateur et c'est la dessus que j'ai besoin d'aide. Je n'ai absolument aucune connaissance de la manière auquel il faut s'y prendre. 

Je vous donne mon code pour que vous pouviez y jeter un oeil 

Le main 

// Main

#include <iostream>
#include <random>
#include "morpion.h"

// JEU DU MORPION

using namespace std;

int main(int argc, const char * argv[])

{
    
    affichage();
  
    return 0;
}

Le header 

#ifndef morpion_h
#define morpion_h

#include <string>
#include <iostream>

void Pions(char &joueur1, char &joueur2);
void affichage();
int debutTour(int &premierAJouer);
char victoire(char emplacements[], char joueur1, char joueur2);

#endif /* morpion_h */

Les fonctions : 

#include <stdio.h>
#include <iostream>
#include "morpion.h"

using namespace std;

void Pions(char &joueur1, char &joueur2)
{
    // Cette fonction définit avec quel type de pions vont jouer les deux joueurs
    int choisi(0);
    
    while (!choisi)
    {
    
    int pions(0);
    cout << "Joueur 1, voulez-vous etre la croix ou le rond ?" << endl;
    cout << "1. La croix" << endl;
    cout << "2. Le rond" << endl;
    cout << "Choix : ";
    cin >> pions;
    
    
        
        if (pions == 1)
        {
            cout << "Joueur 1, vous avez choisi la croix. Joueur 2 vous avez donc le rond" << endl;
            joueur1 = 'X';
            joueur2 = 'O';
            choisi = 1;
        }
        else if (pions == 2)
        {
            cout << "Joueur 1, vous avez choisi le rond. Joueur 2 vous avez donc la croix" << endl;
            joueur1 = 'O';
            joueur2 = 'X';
            choisi = 1;
        }
        else
        {
            cout << "Vous n'avez pas choisi un bon numero!" << endl;
           
        }
        
    }
    
}








void affichage() // Affiche et lance la partie de morpion
{
    char emplacements[9] = {'_', '_','_','_','_','_','_','_','_',}; // initialisation du morpion
    int typeDePartie(0);
   
    cout << "*** MENU ***" << endl;
    cout << "1. Partie multijoueur" << endl << endl; // pour l'instant seulement multijoueur
    cout << "Quel est votre option ? :";
    cin >> typeDePartie;
    
    if (typeDePartie == 1) // mode multijoueur lancé
    {
        
        char joueur1('Z'), joueur2('Z'); // initialisation des pions
        
        cout << "Vous avez lance une partie en mode multijoueur" << endl;
        
        Pions(joueur1, joueur2); // fonction de répartition des pions
        
        
        cout << "Joueur 1 est : " << joueur1 << " Joueur 2 est : " << joueur2 << endl;
        
    
    int debutDuTour(0);
    debutTour(debutDuTour); // A ce niveau la on sait qui commence la partie
    int decisionJoueur1(0), decisionJoueur2(0);
    
    for(int i = 0; i < emplacements[i]; i++) // on lit a chaque fois le morpion pour savoir si il reste une place
    {
        if (emplacements[i] == '_')
        {
           if (debutDuTour == 1) // joueur 1 commence la partie et les autres tours s'enchainent
           {
               cout << endl << endl;
               cout << "                          0    1    2 " << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                        | "  << emplacements[0]<<"  | "<< emplacements[1]<<"  | "<< emplacements[2]<<"  |"<< endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                          3    4    5 " << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                        | "  << emplacements[3]<<"  | "<< emplacements[4]<<"  | "<< emplacements[5]<<"  |"<< endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                          6    7    8 " << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                        | "  << emplacements[6]<<"  | "<< emplacements[7]<<"  | "<< emplacements[8]<<"  |"<< endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                         ---- ---- ----" << endl;
               victoire(emplacements, joueur1, joueur2);
               
               cout << "Joueur 1, où voulez-vous posez votre pion ?" << endl;
               cout << "Choix : ";
               cin >> decisionJoueur1;
               if (emplacements[decisionJoueur1] == '_')
               {
                   emplacements[decisionJoueur1] = joueur1;
               }
               else
               {
                   cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << endl;
               }
              
               cout << endl << endl;
               cout << "                          0    1    2 " << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                        | "  << emplacements[0]<<"  | "<< emplacements[1]<<"  | "<< emplacements[2]<<"  |"<< endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                          3    4    5 " << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                        | "  << emplacements[3]<<"  | "<< emplacements[4]<<"  | "<< emplacements[5]<<"  |"<< endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                          6    7    8 " << endl;
               cout << "                         ---- ---- ----" << endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                        | "  << emplacements[6]<<"  | "<< emplacements[7]<<"  | "<< emplacements[8]<<"  |"<< endl;
               cout << "                        |    |    |    |" << endl;
               cout << "                         ---- ---- ----" << endl;
               victoire(emplacements, joueur1, joueur2);
               
               cout << "Joueur 2, où voulez-vous posez votre pion ?" << endl;
               cout << "Choix : ";
               cin >> decisionJoueur2;
               if (emplacements[decisionJoueur2] == '_')
               {
                   emplacements[decisionJoueur2] = joueur2;
               }
               else
               {
                   cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << endl;
               }
           }
            else if (debutDuTour == 2) // joueur 2 commence la partie et les tours s'enchainent
            {
                cout << endl << endl;
                cout << "                          0    1    2 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[0]<<"  | "<< emplacements[1]<<"  | "<< emplacements[2]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                          3    4    5 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[3]<<"  | "<< emplacements[4]<<"  | "<< emplacements[5]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                          6    7    8 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[6]<<"  | "<< emplacements[7]<<"  | "<< emplacements[8]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                victoire(emplacements, joueur1, joueur2);
                cout << "Joueur 2, où voulez-vous posez votre pion ?" << endl;
                cout << "Choix : ";
                cin >> decisionJoueur2;
                if (emplacements[decisionJoueur2] == '_')
                {
                    emplacements[decisionJoueur2] = joueur2;
                }
                else
                {
                    cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << endl;
                }
                
                cout << endl << endl;
                cout << "                          0    1    2 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[0]<<"  | "<< emplacements[1]<<"  | "<< emplacements[2]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                          3    4    5 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[3]<<"  | "<< emplacements[4]<<"  | "<< emplacements[5]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                          6    7    8 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[6]<<"  | "<< emplacements[7]<<"  | "<< emplacements[8]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                victoire(emplacements, joueur1, joueur2);
                cout << "Joueur 1, où voulez-vous posez votre pion ?" << endl;
                cout << "Choix : ";
                cin >> decisionJoueur1;
                if (emplacements[decisionJoueur1] == '_')
                {
                    emplacements[decisionJoueur1] = joueur1;
                }
                else
                {
                    cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << endl;
                }
                
                
                
            } // fermeture boucle debutDePartie
            
        }
        else
        {
            cout << "La partie est fini" << endl;
            victoire(emplacements, joueur1, joueur2);
        }
    }
        
        
 
    
    }
    }








    
int debutTour(int &premierAJouer) // définit qui commence à jouer en premier
{
    while (premierAJouer != 1 && premierAJouer != 2)
    {
    
    
    cout << "1. Si vous voulez que le joueur 1 commence la partie" << endl;
    cout << "2. Si vous voulez que le joueur 2 commence la partie" << endl << endl;
    cout << "choix : ";
    cin >> premierAJouer;
    if (premierAJouer != 1 && premierAJouer != 2)
    {
        cout << "Vous n'avez pas rentre un nombre valide" << endl;
    }
    }
    return premierAJouer;
    
}



char victoire(char emplacements[], char joueur1, char joueur2)
{
    int test(0);
    // Si le joueur 1 a gagne
    for(int i = 0; i < emplacements[i]; i++)
    {
        if ((emplacements[0] == joueur1 && emplacements[1] == joueur1 && emplacements[2] == joueur1) || (emplacements[3] == joueur1 && emplacements[4] == joueur1 && emplacements[5] == joueur1) || (emplacements[6] == joueur1 && emplacements[7] == joueur1 && emplacements[8] == joueur1) || (emplacements[0] == joueur1 && emplacements[3] == joueur1 && emplacements[6] == joueur1) || (emplacements[1] == joueur1 && emplacements[4] == joueur1 && emplacements[7] == joueur1) || (emplacements[2] == joueur1 && emplacements[5] == joueur1 && emplacements[8] == joueur1) || (emplacements[0] == joueur1 && emplacements[4] == joueur1 && emplacements[8] == joueur1) || (emplacements[2] == joueur1 && emplacements[4] == joueur1 && emplacements[6] == joueur1))
        {
            cout << "Le joueur 1 a gagne! BRAVO" << endl;
            exit(0);
        }
        
         
    }
    // Si le joueur 2 a gagne
    for(int i = 0; i < emplacements[i]; i++)
    {
        if ((emplacements[0] == joueur2 && emplacements[1] == joueur2 && emplacements[2] == joueur2) || (emplacements[3] == joueur2 && emplacements[4] == joueur2 && emplacements[5] == joueur2) || (emplacements[6] == joueur2 && emplacements[7] == joueur2 && emplacements[8] == joueur2) || (emplacements[0] == joueur2 && emplacements[3] == joueur2 && emplacements[6] == joueur2) || (emplacements[1] == joueur2 && emplacements[4] == joueur2 && emplacements[7] == joueur2) || (emplacements[2] == joueur2 && emplacements[5] == joueur2 && emplacements[8] == joueur2) || (emplacements[0] == joueur2 && emplacements[4] == joueur2 && emplacements[8] == joueur2) || (emplacements[2] == joueur2 && emplacements[4] == joueur2 && emplacements[6] == joueur2))
        {
            cout << "Le joueur 2 a gagne! BRAVO" << endl;
            exit(0);
        }
        
        
    }
    
    return test;
}

Voila 

La première remarque, c'est que ton code est bien long, et contient 4 fois la même séquence d'instructions pour faire afficher la grille.

Donc tu as tout intérêt à en faire une seule fonction, appelée 4 fois. On y verra plus clair après.

Règle #1 : ne pas réécrire plusieurs fois le même code.

-
Edité par michelbillaud 28 août 2016 à 11:55:14

Bonjour, oulà, alors il y a énormément de points à aborder, mais le plus important va être ce que t'a déjà dit Michelbillaud.

SRP -> Single Responsibility Principle

Une fonction ne doit avoir qu'une seule vocation, de ce fait ta fonction affichage() ne respecte pas ce principe. Il semble évident que ce code : 

cout << endl << endl;
                cout << "                          0    1    2 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[0]<<"  | "<< emplacements[1]<<"  | "<< emplacements[2]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                          3    4    5 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[3]<<"  | "<< emplacements[4]<<"  | "<< emplacements[5]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                          6    7    8 " << endl;
                cout << "                         ---- ---- ----" << endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                        | "  << emplacements[6]<<"  | "<< emplacements[7]<<"  | "<< emplacements[8]<<"  |"<< endl;
                cout << "                        |    |    |    |" << endl;
                cout << "                         ---- ---- ----" << endl;
                

Aurait sa place dans une fonction (par exemple showGrid()), au lieu d'avoir à le réécrire partout.

Pour ta fonction de test victoire, au lieu de faire deux boucles for la première suffit.

for(int i = 0; i < emplacements[i]; i++)
    {
        if ((emplacements[0] == joueur1 && emplacements[1] == joueur1 && emplacements[2] == joueur1) || (emplacements[3] == joueur1 && emplacements[4] == joueur1 && emplacements[5] == joueur1) || (emplacements[6] == joueur1 && emplacements[7] == joueur1 && emplacements[8] == joueur1) || (emplacements[0] == joueur1 && emplacements[3] == joueur1 && emplacements[6] == joueur1) || (emplacements[1] == joueur1 && emplacements[4] == joueur1 && emplacements[7] == joueur1) || (emplacements[2] == joueur1 && emplacements[5] == joueur1 && emplacements[8] == joueur1) || (emplacements[0] == joueur1 && emplacements[4] == joueur1 && emplacements[8] == joueur1) || (emplacements[2] == joueur1 && emplacements[4] == joueur1 && emplacements[6] == joueur1))
        {
            cout << "Le joueur 1 a gagne! BRAVO" << endl;
            exit(0);
        }
         
     /* else if(){
            //
        }  */
    }

Pourquoi ne pas tester la  possibilité de victoire des deux directement ?

"Si le joueur 1 n'a pas gagné, alors tester la même chose pour le joueur 2..."

Lorsque j'ai vu la taille de ta condition pour tout t'avouer je n'ai même pas eu la force de lire le début. Peut-être peux-tu l'optimiser un minimum ? Je n'y comprends pas grand chose, n'oublie pas "Ce qui se conçoit bien s'énonce clairement".

Tu es en C++ et pas en C, alors dis "adieu" aux tableaux primitifs. char tab[]{} et j'en passe tu oublies.

Tu veux un tableau contenant des entiers sans en connaître la taille ?

std::vector<int> v {};

Un tableau contenant très exactement 9 chaines de caractères ?

std::array<std::string, 9> a {};

Egalement, mais là en l'occurence ce n'est pas le problème le plus important, évite d'utiliser 

using namespace std;

Préfère les utiliser de manière plus stricte "using std::cout;", ou encore mieux, appeler les fonctions de la librairie standard comme il se doit : "std::cout". Au début tu ne te rends peut-être pas compte de l'utilité de cette manipulation, mais fais moi confiance, prends l'habitude dès maintenant.

-
Edité par Yukiro 28 août 2016 à 12:55:57

Mon code raccourci : 

#include <stdio.h>
#include <iostream>
#include "morpion.h"





void Pions(char &joueur1, char &joueur2)
{
    // Cette fonction définit avec quel type de pions vont jouer les deux joueurs
    int choisi(0);
    
    while (!choisi)
    {
    
    int pions(0);
    std::cout << "Joueur 1, voulez-vous etre la croix ou le rond ?" << std::endl
        ;
    std::cout << "1. La croix" << std::endl;
    std::cout << "2. Le rond" << std::endl;
    std::cout << "Choix : ";
    std::cin >> pions;
    
    
        
        if (pions == 1)
        {
            std::cout << "Joueur 1, vous avez choisi la croix. Joueur 2 vous avez donc le rond" << std::endl;
            joueur1 = 'X';
            joueur2 = 'O';
            choisi = 1;
        }
        else if (pions == 2)
        {
            std::cout << "Joueur 1, vous avez choisi le rond. Joueur 2 vous avez donc la croix" << std::endl;
            joueur1 = 'O';
            joueur2 = 'X';
            choisi = 1;
        }
        else
        {
            std::cout << "Vous n'avez pas choisi un bon numero!" << std::endl;
           
        }
        
    }
    
}








void affichage() // Affiche et lance la partie de morpion
{
    char emplacements[9] = {'_', '_','_','_','_','_','_','_','_',}; // initialisation du morpion
    int typeDePartie(0);
   
    std::cout << "*** MENU ***" << std::endl;
    std::cout << "1. Partie multijoueur" << std::endl << std::endl; // pour l'instant seulement multijoueur
    std::cout << "Quel est votre option ? :";
    
    std::cin
    >> typeDePartie;
    
    if (typeDePartie == 1) // mode multijoueur lancé
    {
        
        char joueur1('Z'), joueur2('Z'); // initialisation des pions
        
        std::cout << "Vous avez lance une partie en mode multijoueur" << std::endl;
        
        Pions(joueur1, joueur2); // fonction de répartition des pions
        
        
        std::cout << "Joueur 1 est : " << joueur1 << " Joueur 2 est : " << joueur2 << std::endl;
        
    
    int debutDuTour(0);
    debutTour(debutDuTour); // A ce niveau la on sait qui commence la partie
    int decisionJoueur1(0), decisionJoueur2(0);
    
    for(int i = 0; i < emplacements[i]; i++) // on lit a chaque fois le morpion pour savoir si il reste une place
    {
        if (emplacements[i] == '_')
        {
           if (debutDuTour == 1) // joueur 1 commence la partie et les autres tours s'enchainent
           {
               morpion(emplacements);
               victoire(emplacements, joueur1, joueur2);
               
               std::cout << "Joueur 1, où voulez-vous posez votre pion ?" << std::endl;
               std::cout << "Choix : ";
               std::cin >> decisionJoueur1;
               if (emplacements[decisionJoueur1] == '_')
               {
                   emplacements[decisionJoueur1] = joueur1;
               }
               else
               {
                   std::cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << std::endl;
               }
              
               morpion(emplacements);
               victoire(emplacements, joueur1, joueur2);
               
               std::cout << "Joueur 2, où voulez-vous posez votre pion ?" << std::endl;
               std::cout << "Choix : ";
               std::cin >> decisionJoueur2;
               if (emplacements[decisionJoueur2] == '_')
               {
                   emplacements[decisionJoueur2] = joueur2;
               }
               else
               {
                   std::cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << std::endl;
               }
           }
            else if (debutDuTour == 2) // joueur 2 commence la partie et les tours s'enchainent
            {
                morpion(emplacements);
                victoire(emplacements, joueur1, joueur2);
                
                std::cout << "Joueur 2, où voulez-vous posez votre pion ?" << std::endl;
                std::cout << "Choix : ";
                std::cin >> decisionJoueur2;
                if (emplacements[decisionJoueur2] == '_')
                {
                    emplacements[decisionJoueur2] = joueur2;
                }
                else
                {
                    std::cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << std::endl;
                }
                
                morpion(emplacements);
                victoire(emplacements, joueur1, joueur2);
                std::cout << "Joueur 1, où voulez-vous posez votre pion ?" << std::endl;
                std::cout << "Choix : ";
                std::cin >> decisionJoueur1;
                if (emplacements[decisionJoueur1] == '_')
                {
                    emplacements[decisionJoueur1] = joueur1;
                }
                else
                {
                    std::cout << "Vous ne pouvez pas placez votre pion a cet endroit car il est deja occupe donc vous perdez votre tour" << std::endl;
                }
                
                
                
            } // fermeture boucle debutDePartie
            
        }
        else
        {
            std::cout << "La partie est fini" << std::endl;
            victoire(emplacements, joueur1, joueur2);
        }
    }
        
        
 
    
    }
    }








    
int debutTour(int &premierAJouer) // définit qui commence à jouer en premier
{
    while (premierAJouer != 1 && premierAJouer != 2)
    {
    
    
    std::cout << "1. Si vous voulez que le joueur 1 commence la partie" << std::endl;
    std::cout << "2. Si vous voulez que le joueur 2 commence la partie" << std::endl << std::endl;
    std::cout << "choix : ";
    std::cin >> premierAJouer;
    if (premierAJouer != 1 && premierAJouer != 2)
    {
        std::cout << "Vous n'avez pas rentre un nombre valide" << std::endl;
    }
    }
    return premierAJouer;
    
}



char victoire(char emplacements[], char joueur1, char joueur2)
{
    int test(0);
    // Si le joueur 1 a gagne
    for(int i = 0; i < emplacements[i]; i++)
    {
        if ((emplacements[0] == joueur1 && emplacements[1] == joueur1 && emplacements[2] == joueur1) || (emplacements[3] == joueur1 && emplacements[4] == joueur1 && emplacements[5] == joueur1) || (emplacements[6] == joueur1 && emplacements[7] == joueur1 && emplacements[8] == joueur1) || (emplacements[0] == joueur1 && emplacements[3] == joueur1 && emplacements[6] == joueur1) || (emplacements[1] == joueur1 && emplacements[4] == joueur1 && emplacements[7] == joueur1) || (emplacements[2] == joueur1 && emplacements[5] == joueur1 && emplacements[8] == joueur1) || (emplacements[0] == joueur1 && emplacements[4] == joueur1 && emplacements[8] == joueur1) || (emplacements[2] == joueur1 && emplacements[4] == joueur1 && emplacements[6] == joueur1))
        {
            std::cout << "Le joueur 1 a gagne! BRAVO" << std::endl;
            exit(0);
        }
        else if((emplacements[0] == joueur2 && emplacements[1] == joueur2 && emplacements[2] == joueur2) || (emplacements[3] == joueur2 && emplacements[4] == joueur2 && emplacements[5] == joueur2) || (emplacements[6] == joueur2 && emplacements[7] == joueur2 && emplacements[8] == joueur2) || (emplacements[0] == joueur2 && emplacements[3] == joueur2 && emplacements[6] == joueur2) || (emplacements[1] == joueur2 && emplacements[4] == joueur2 && emplacements[7] == joueur2) || (emplacements[2] == joueur2 && emplacements[5] == joueur2 && emplacements[8] == joueur2) || (emplacements[0] == joueur2 && emplacements[4] == joueur2 && emplacements[8] == joueur2) || (emplacements[2] == joueur2 && emplacements[4] == joueur2 && emplacements[6] == joueur2))
        {
            std::cout << "Le joueur 2 a gagne! BRAVO" << std::endl;
            exit(0);
        }

    }
    
    return test;
}

char morpion(char emplacements[])
{
    int test(0);
    std::cout << std::endl << std::endl;
    std::cout << "                          0    1    2 " << std::endl;
    std::cout << "                         ---- ---- ----" << std::endl;
    std::cout << "                        |    |    |    |" << std::endl;
    std::cout << "                        | "  << emplacements[0]<<"  | "<< emplacements[1]<<"  | "<< emplacements[2]<<"  |"<< std::endl;
    std::cout << "                        |    |    |    |" << std::endl;
    std::cout << "                         ---- ---- ----" << std::endl;
    std::cout << "                          3    4    5 " << std::endl;
    std::cout << "                         ---- ---- ----" << std::endl;
    std::cout << "                        |    |    |    |" << std::endl;
    std::cout << "                        | "  << emplacements[3]<<"  | "<< emplacements[4]<<"  | "<< emplacements[5]<<"  |"<< std::endl;
    std::cout << "                        |    |    |    |" << std::endl;
    std::cout << "                         ---- ---- ----" << std::endl;
    std::cout << "                          6    7    8 " << std::endl;
    std::cout << "                         ---- ---- ----" << std::endl;
    std::cout << "                        |    |    |    |" << std::endl;
    std::cout << "                        | "  << emplacements[6]<<"  | "<< emplacements[7]<<"  | "<< emplacements[8]<<"  |"<< std::endl;
    std::cout << "                        |    |    |    |" << std::endl;
    std::cout << "                         ---- ---- ----" << std::endl;
    return test;
}

Pour la fonction victoire je teste toutes les possibilités, je dis que si la croix par exemple se trouve dans la case 0, 1 et 2, on a une ligne donc le programme doit dire que le joueur qui possède la croix a gagné, je ne sais pas comment le faire autrement

-
Edité par LE Codeur Padawan 28 août 2016 à 13:03:16

Il en est de même pour les lignes 91 à 118, que l'on retrouve 2 fois.

J'ai renoncé à comprendre dans quelle variable se trouvait le numéro du joueur mais on pourrait faire

cout << "Joueur " << numeroDuJoueur
     << ", où voulez vous jouer ?"
     << endl;

et le reste à l'avenant.

Oublie pas vu morpion.h

-
Edité par Yukiro 28 août 2016 à 13:05:04

-
Edité par LE Codeur Padawan 28 août 2016 à 13:12:52

J'ai pas réussi à réduire la taille du code plus que ça. et michel pour te répondre je n'ai pas fais de variable numéro du joueur, le joueur est définit par le pion qu'il choisit dans mon code. Si le joueur1 choisit la croix il devient joueur croix. 

Mais je vous remercie tout d'abord grandement pour votre implication Yukio et Michel et je m'excuse si mon code n'est pas claire. 

Est-ce que quelqu'un pourrait m'expliquer comment crée une IA afin que je puisse faire une partie solo contre l'ordinateur ???

Viendrais-tu d'un langage procédural sans objets ?

Tu as plusieurs variables concernant les joueurs. Tu pourrais très bien les rassembler en un ensemble cohérent : une classe. Que peut faire un joueur ? Avoir un nom (éventuellement "Joueur 1" et "Joueur 2"), un type de représentation ("O" ou "X" par exemple), et doit être capable d'effectuer 1 action.

class Player
{
  public:
    using name_type = std::string;
    using representation_type = std::string;
    using response_type = int;

    name_type getName() const;
    representation_type getRepresentation() const;
    response_type play(const Board& board) = 0;
};

Comment savoir comment jouer ? Pour un joueur humain, on va lui poser la question. Pour une IA, elle va le calculer toute seule.

class HumanPlayer : public Player
{
  public:
    response_type play(const Board& board) override;
};

class ComputerPlayer : public Player
{
  public:
    response_type play(const Board& board) override;
};

Comme affiché, ce n'est pas le joueur qui modifie le plateau. Comme ça, le joueur ne peut pas tricher. Vient ensuite la classe Board. Que doit-elle offrir ?

• savoir qui a joué où
• jouer un coup et de dire si ce coup est légal ou non
• dire s'il y a un gagnant, et si oui, qui

D'accord Anolya, il est vrai que dans mon programme je n'utilise pas d'objets.

Mais comment coder la partie ordinateur pour que quand c'est à lui de jouer il fasse le choix le plus logique et intéressant pour lui ?? 

Par ailleurs,

est-ce que l'ordinateur doit seulement savoir :

- quand m'empêcher de gagner

- comment gagner

ou alors sans que le code soit trop complexe je peux lui permettre de voir en plus plusieurs coups à l'avance ? De manière a ce qu'il y est une difficulté (facile, moyen, difficile) 

Bonjour,

utilisation de l'algorithme min-max

http://turing.cs.pub.ro/auf2/html/chapters/chapter3/chapter_3_4_2.html

Essaie de réfléchir.

Que faut-il pour gagner ? Il faut que, quels que soient les coups suivants joués, tu aies toujours une manière de gagner. Le but va être de déterminer le meilleur coup qui corresponde au maximum à ces critères. Comment faire ? On va essayer toutes les combinaisons de coups possibles. Si la situation est gagnante, tu vas lui donner un bon score. Si la situation est perdante, tu vas chercher à l'éviter en lui donnant un mauvais score. Maintenant qu'on a toutes nos combinaisons finales, comment noter le coup qui précédait juste le coup final ? Et bien si c'est toi qui doit jouer le dernier coup, alors tu vas dire que ce coup mène au meilleur pour toi. Tu vas donc le noter avec la note maximale des fils dans l'arbre. Et on va remonter comme ça jusqu'à la racine pour savoir quel coup jouer. Le problème, c'est que tu n'es pas seul à jour. Comment joue ton adversaire ? On a besoin de faire une supposition ici : l'adversaire va faire le coup qui lui est le plus prometteur. Il va donc forcément jouer le coup qui maximise SON score (et donc minimise le tien).

Supposons que l'on est à ce point :

XOX
___
_O_

C'est à X de jouer. Il va essayer toutes ces combinaisons :

XOX  XOX  XOX  XOX  XOX
X__  _X_  __X  ___  ___
_O_  _O_  _O_  XO_  _OX

Quel est le poids du premier choix ? Le coup suivant serait pour O. Il va tester tout ça :

XOX  XOX  XOX  XOX
XO_  X_O  X__  X__
_O_  _O_  OO_  _OO

Parmi ces solutions, l'une fait gagner O immédiatement. Il va donc la sélectionner (en considérant une optimisation de l'algorithme). Son score va être de 1. Par conséquence, le score de X avec le premier coup sera de -1 car il va perdre.

Testons maintenant le deuxième choix. O peut faire ça :

XOX  XOX  XOX  XOX
OX_  _XO  _X_  _X_
_O_  _O_  OO_  _OO

Aucune position n'est gagnante ou perdante donc on va devoir aller une étape plus loin. Dans tous les cas, il y aura une position X gagnante donc X choisira l'une d'elle. Le choix de O mènera forcément à la défaite donc le score de O est de -1. Le score de X pour le 2ème choix est donc de 1. X va donc choisir cette position pour être sûr de gagner.

A propos des objets : c'est une erreur de conception de débutant de vouloir absolument "réifier" (faire des objets avec tout ce qui te tombe sous la main). 

Dans le jeu réel, il y a des Joueurs qui remplissent des Cases d'une Grille avec des Trucs qui sont des Ronds et des Croix. Et puis des Alignements qui regroupent des Cases. Et puis une Table, et des Chaises, qui heritent des Meubles avec des Pieds.

Mais nous, on ne fait pas une imitation douteuse du monde réel, mais une modélisation du jeu.

Oon fait tout aussi bien le boulot avec un tableau avec 9 cases, remplies par 1 quand c'est le joueur 1, 2 quand c'est le joueur 2, et 0 quand la case est vide.  Et la représentation graphique est obtenue par un tableau de caractères

int grille[3][3];    // 0, 1 ou 2
int joueur;          // 1 ou 2
const char representation[] = { ' ', 'O', 'X' };

comme modélisation des données c'est largement suffisant.

-
Edité par michelbillaud 28 août 2016 à 22:55:09

l'IA c'est t'une INTELLIGENCE artifiicielle. Elle doit apprendre d'abord comment fonctionne le jeu !

Tu peux lui enseigner cela avec des fonctions qui utilisent des "return x". Pour cela je te conseille de faire comme avec du binaire des 0 et des 1. 1=bon;0=pas_bon. Cela permet de dire quand l'IA va preferer defendre en bloquant une case pour que le joueur ne gagne pas ou bien attaquer et placer un pion pour tenter de gagner. Mais tout cela depend de la personnalite de ton IA.Pour que cette personnalite soit configurable, je te conseille de faire un systeme de niveau(facile,moyen,dure).