Bonjour/Bonsoir, après avoir vu cette après-midi ce topic:

-> http://openclassrooms.com/forum/sujet/realisation-d-un-morpion-1

Je me suis mit en tête de faire la même chose, j'ai plus ou moins réussi et je suis donc venu comparer mon code à celui du topic et là ... SURPRISE: J'ai l'impression que mon code faire LOURD, GROS à côté de celui du voisin. Il y a de nombreuse répétitions dans mon code, il n'est pas optimisé et ça me fait de la peine, c'est pourquoi j'aurai besoin de conseils pour m'améliorer et faire un code plus propre, plus efficace.

Pour vous donner une idée je poste mon code (avec des commentaire car je le trouve brouillon.

Le main :

#include <stdio.h>
#include <stdlib.h>
#include "headers.h"

int main(int argc, char* argv[])
{
    int play = 0, colonne = 1, ligne = 1, joueur = 1, t = 0, resultat = 0;
    int array [9] = {0};
    char morpion [] = "_|_|_\n_|_|_\n | | ";
    /*
        00|02|04    array   0|1|2
        06|08|10            3|4|5
        12|14|16            6|7|8
    */
    printf("\n\t\t\tMORPION\n\n");
    do{
            // JOUEUR 1
            if (joueur == 1 && play != 1){ // SI c'est au joueur 1 ET si la partie n'est pas finie
                printf("\n\n%s", morpion); // affiche le morpion
                printf("\nJoueur %d : ", joueur); // affiche le nom du joueur qui doit jouer
                choix(&colonne, &ligne);// demande à l'utilisateur une colonne puis une ligne .....
                t = test(colonne, ligne, array);// ... jusqu'à tomber sur une case libre.
                if (t==0){
                    remplir(array, colonne, ligne, joueur, morpion);// Affiche le Carractère sur le Morpion ET rempli une case du tableau
                    resultatPartie(&resultat, array);// Test si les conditions de victoire sont remplies
                    if (resultat==1){
                        printf("\n\n%s", morpion);// affiche le morpion
                        printf("\n\n\tLe joueur 1 remporte la partie !\n\n");
                        play = 1;
                    }
                    else if (resultat==3){ // egalité qui n'est placée qu'ici car le joueur qui commence finit la partie (9coups possibles)
                        printf("\n\n%s", morpion);// affiche le morpion
                        printf("\n\n\t EGALITE !");
                        play = 1;
                    }
                    joueur = 2;
                }
            }
            // JOUEUR 2
                else if (joueur == 2 && play !=1){
                    printf("\n\n%s", morpion);// affiche le morpion
                    printf("\nJoueur %d : ", joueur);// affiche le nom du joueur qui doit jouer
                    choix(&colonne, &ligne); // demande à l'utilisateur une colonne puis une ligne .....
                    t = test(colonne, ligne, array); // ... jusqu'à tomber sur une case libre.
                    if (t==0){
                        remplir(array, colonne, ligne, joueur, morpion); // Affiche le Carractère sur le Morpion ET rempli une case du tableau
                        resultatPartie(&resultat, array); // Test si les conditions de victoire sont remplies
                        if (resultat==2){
                            printf("\n\n%s", morpion);
                            printf("\n\n\tLe joueur 2 remporte la partie !\n\n");
                            play = 1;
                        }
                        joueur = 1;
                    printf("\n\nt = %d", t);
                }
            }

    }while (play == 0);
    return 0;
}

La fonction Choix :

void choix (int *colonne, int *ligne)
{
    int bufCo = 0;
    int bufLign = 0;
    do{
        printf("\n\tChoisissez une colonne : ");
        scanf("%d", &bufCo);
        printf("\n\tChoisissez une ligne : ");
        scanf("%d", &bufLign);

        *colonne = bufCo;
        *ligne = bufLign;


    } while (*colonne>3 || *colonne<1 || *ligne>3 || *ligne<1);

}

Je trouve que ces parties là sont plutôt compact (j'ai bien dit plutôt, comparé à ce qui arrive)

et le cœur du problème les fonction Remplir, Resultat et Test:

int test (int colonne, int ligne, int array[])
{
    if (colonne==1 && ligne==1 && array[0] != 1 && array[0] != 2){
            return 0;
    }
    else if (colonne==2 && ligne==1 && array[1] != 1 && array[1] != 2){
            return 0;
    }
    else if (colonne==3 && ligne==1 && array[2] != 1 && array[2] != 2){
            return 0;
    }
    else if (colonne==1 && ligne==2 && array[3] != 1 && array[3] != 2){
            return 0;
    }
    else if (colonne==2 && ligne==2 && array[4] != 1 && array[4] != 2){
            return 0;
    }
    else if (colonne==3 && ligne==2 && array[5] != 1 && array[5] != 2){
            return 0;
    }
    else if (colonne==1 && ligne==3 && array[6] != 1 && array[6] != 2){
            return 0;
    }
    else if (colonne==2 && ligne==3 && array[7] != 1 && array[7] != 2){
            return 0;
    }
    else if (colonne==3 && ligne==3 && array[8] != 1 && array[8] != 2){
            return 0;
    }
    else{
        return 1;
    }
}

void resultatPartie (int *resultat, int array[])
{
    // JOUEUR 1
    if (array[0] == 1 && array[3] == 1 && array [6] == 1){ // 1
        *resultat = 1;
    }
    else if (array[1] == 1 && array[4] == 1 && array [7] == 1){ // 2
        *resultat = 1;
    }
    else if (array[2] == 1 && array[5] == 1 && array [8] == 1){ // 3
        *resultat = 1;
    }
    else if (array[0] == 1 && array[1] == 1 && array [2] == 1){ // 4
        *resultat = 1;
    }
    else if (array[3] == 1 && array[4] == 1 && array [5] == 1){ // 5
        *resultat = 1;
    }
    else if (array[6] == 1 && array[7] == 1 && array [8] == 1){ // 6
        *resultat = 1;
    }
    else if (array[0] == 1 && array[4] == 1 && array [8] == 1){ // 7
        *resultat = 1;
    }
    else if (array[2] == 1 && array[4] == 1 && array [6] == 1){ // 8
        *resultat = 1;
    }

    // JOUEUR 2
    else if (array[0] == 2 && array[3] == 2 && array [6] == 2){ // 1
        *resultat = 2;
    }
    else if (array[1] == 2 && array[4] == 2 && array [7] == 2){ // 2
        *resultat = 2;
    }
    else if (array[2] == 2 && array[5] == 2 && array [8] == 2){ // 3
        *resultat = 2;
    }
    else if (array[0] == 2 && array[1] == 2 && array [2] == 2){ // 4
        *resultat = 2;
    }
    else if (array[3] == 2 && array[4] == 2 && array [5] == 2){ // 5
        *resultat = 2;
    }
    else if (array[6] == 2 && array[7] == 2 && array [8] == 2){ // 6
        *resultat = 2;
    }
    else if (array[0] == 2 && array[4] == 2 && array [8] == 2){ // 7
        *resultat = 2;
    }
    else if (array[2] == 2 && array[4] == 2 && array [6] == 2){ // 8
        *resultat = 2;
    }

    // EGALITE

    else if ((array[0] == 1 || array[0] == 2) && (array[1] == 1 || array[1] == 2) && (array[2] == 1 || array[2] == 2) && (array[3] == 1 || array[3] == 2) && (array[4] == 1 || array[4] == 2) && (array[5] == 1 || array[5] == 2) && (array[6] == 1 || array[6] == 2) && (array[7] == 1 || array[7] == 2) && (array[8] == 1 || array[8] == 2)){
        *resultat = 3;
    }
}

La dernière et la pire à mes yeux :

void remplir (int array[], int colonne, int ligne, int joueur, char string[])
{
    if (colonne==1 && ligne==1){
            if (joueur==1){
                array[0] = 1;
                string[0] = 'X';
            }
            else{
                array[0] = 2;
                string[0] = 'O';
            }
    }
    else if (colonne==2 && ligne==1){
            if (joueur==1){
                array[1] = 1;
                string[2] = 'X';
            }
            else{
                array[1] = 2;
                string[2] = 'O';
            }
    }
    else if (colonne==3 && ligne==1){
            if (joueur==1){
                array[2] = 1;
                string[4] = 'X';
            }
            else{
                array[2] = 2;
                string[4] = '0';
            }
    }
    else if (colonne==1 && ligne==2){
            if (joueur==1){
                array[3] = 1;
                string[6] = 'X';
            }
            else{
                array[3] = 2;
                string[6] = '0';
            }
    }
    else if (colonne==2 && ligne==2){
            if (joueur==1){
                array[4] = 1;
                string[8] = 'X';
            }
            else{
                array[4] = 2;
                string[8] = 'O';
            }
    }
    else if (colonne==3 && ligne==2){
            if (joueur==1){
                array[5] = 1;
                string[10] = 'X';
            }
            else{
                array[5] = 2;
                string[10] = 'O';
            }
    }
    else if (colonne==1 && ligne==3){
            if (joueur==1){
                array[6] = 1;
                string[12] = 'X';
            }
            else{
                array[6] = 2;
                string[12] = '0';
            }
    }
    else if (colonne==2 && ligne==3){
            if (joueur==1){
                array[7] = 1;
                string[14] = 'X';
            }
            else{
                array[7] = 2;
                string[14] = 'O';
            }
    }
    else if (colonne==3 && ligne==3){
            if (joueur==1){
                array[8] = 1;
                string[16] = 'X';
            }
            else{
                array[8] = 2;
                string[16] = 'O';
            }
    }
}

Je pense que le problème est bien visible, d'où ma question: Comment faire pour éviter ces  codes répétitifs à rallonges ? Mieux penser son programme ? (Ce que je suis incapable de faire pour le moment, je code sans savoir où je vais la plupart du temps) Si oui, comment apprendre ? Faire des algorithme avant de ce lancer, penser à utiliser le moins de ressources possible ? C'est compliqué pour un débutant, y a t-il un cours pour apprendre ? Juste besoin de pratique ? (C'est mon premier gros projet en dehors du TP plus ou moins du cours dispo sur le site, je n'ai pas encore fait le pendu). Voilà j'aimerai apprendre à mieux penser mon code, si vous pouviez au moins me dire comment éviter les pièges dans lesquels je suis tombé aujourd'hui, merci d'avance.

Ps: J'ai pensé utiliser des boucles mais je ne voyais pas comment les faire avec ces conditions/variables qui changeaient à chaque fois.

-
Edité par Neostique 27 mai 2015 à 22:30:26

OMG tu me copies 

Personnellement à la plase de tout tes if...else if...else if.. j'utiliserai des switch c'est bien pratique ! Pour le reste je ne peux pas trop te dire je débute également

Charles.F a écrit:

OMG tu me copies 

Personnellement à la plase de tout tes if...else if...else if.. j'utiliserai des switch c'est bien pratique ! Pour le reste je ne peux pas trop te dire je débute également

J'aimerai bien te copier, ton code fait propre comparé au mien, pas de gros pâtés bourré de répétition ou juste un nombre change dans une conditions j'essaie encore de comprendre ton code car il est bien trop subtil pour un bourrin comme moi j'ai l'impression.

Je peux essayé de t'expliqué ma démarche si tu veux:

 je me suis dis pour gagner il faut que trois symboles soient alignés donc chaque case de ma grille (les chiffres derrières les cases sont respectivement la ligne puis la colonne) ont une valeur , quand on place un cercle la valeur de cette case passe à 0 et quand on mais une croix elle passe à 2. J'ai initialisé toutes les cases à des valeurs différentes car ma condition pour gagné c'est que trois cases alignées est la même valeur (donc si elles avaient été initialisé à la même valeur le jeu sera déjà gagné car trois cases alignées ont la même valeur). Pour la gestion des cases prises j'ai créer un tableau 3x3 initialisé à 0 et un 1 se place dès qu'une est prise afin de ne pas pouvoir réécrire dedans et gérer le cas de l'égalité quand la grille est pleine et que personne n'a gagné.

Le tour des 2 joueurs sont compris dans un while dont je ne sors que si la condition de victoire et réalisé (ou l'égalité qui contient un exit). Les deux tours sont exactement les mêmes sauf que les valeurs change (0 est placé dans une case pour les 0 et 2 pour les X)et que pour que le joueur 2 ne puisse pas jouer si le joueur1 a gagné j'ai rajouté un si devant le tour du joueur 2.

voila voila

Après sache que mon code n'est pas encore au point car comme tu l'as peut être vu dans mon topic mon programme ne détecte pas quand les X gagne... 

C'est la démarche pour savoir si trois symboles sont alignés que je ne comprends pas comment tu t'y es prit en fait. En tout il y a 8 possibilités pour gagner au morpion, moi je les test toutes une par une (les 16 donc vu qu'il y a deux joueurs) et je les test de la manière suivante:

-je crée un tableau de 9cases (une pour chaque case du morpion)

-je mets les valeurs en fonction du joueur qui à joué dans la case (Par exemple la tableau[0] correspond à la case tout en haut à gauche si sa valeur est 2 c'est que le joueur 2 à joué dedans)

-et là je bloque car je ne trouve pas de moyen plus simple que de tester toutes les possibilités de cases alignées de cette manière :

void resultatPartie (int *resultat, int array[])
{
    // JOUEUR 1
    if (array[0] == 1 && array[3] == 1 && array [6] == 1){ // 1
        *resultat = 1;
    }
    else if (array[1] == 1 && array[4] == 1 && array [7] == 1){ // 2
        *resultat = 1;
    }
    else if (array[2] == 1 && array[5] == 1 && array [8] == 1){ // 3
        *resultat = 1;
    }
    else if (array[0] == 1 && array[1] == 1 && array [2] == 1){ // 4
        *resultat = 1;
    }
    else if (array[3] == 1 && array[4] == 1 && array [5] == 1){ // 5
        *resultat = 1;
    }
    else if (array[6] == 1 && array[7] == 1 && array [8] == 1){ // 6
        *resultat = 1;
    }
    else if (array[0] == 1 && array[4] == 1 && array [8] == 1){ // 7
        *resultat = 1;
    }
    else if (array[2] == 1 && array[4] == 1 && array [6] == 1){ // 8
        *resultat = 1;
    }

    // JOUEUR 2
    else if (array[0] == 2 && array[3] == 2 && array [6] == 2){ // 1
        *resultat = 2;
    }
    else if (array[1] == 2 && array[4] == 2 && array [7] == 2){ // 2
        *resultat = 2;
    }
    else if (array[2] == 2 && array[5] == 2 && array [8] == 2){ // 3
        *resultat = 2;
    }
    else if (array[0] == 2 && array[1] == 2 && array [2] == 2){ // 4
        *resultat = 2;
    }
    else if (array[3] == 2 && array[4] == 2 && array [5] == 2){ // 5
        *resultat = 2;
    }
    else if (array[6] == 2 && array[7] == 2 && array [8] == 2){ // 6
        *resultat = 2;
    }
    else if (array[0] == 2 && array[4] == 2 && array [8] == 2){ // 7
        *resultat = 2;
    }
    else if (array[2] == 2 && array[4] == 2 && array [6] == 2){ // 8
        *resultat = 2;
    }

    // EGALITE

    else if ((array[0] == 1 || array[0] == 2) && (array[1] == 1 || array[1] == 2) && (array[2] == 1 || array[2] == 2) && (array[3] == 1 || array[3] == 2) && (array[4] == 1 || array[4] == 2) && (array[5] == 1 || array[5] == 2) && (array[6] == 1 || array[6] == 2) && (array[7] == 1 || array[7] == 2) && (array[8] == 1 || array[8] == 2)){
        *resultat = 3;
    }
}

Comment tu t'y es prit pour faire tester les possibilités si simplement dans ton programme, c'est ça que je comprends pas. (Si tu pouvais me link le bout de ton code qui test les possibilités de victoire, j'en serai ravi ! )

A ok

Alors malheureusement ce bout de code est faux mes conditions ne sont pas bonnes ce qui créer l'erreur mais je vais t'expliqué ce que j'ai fais:

Dans mon code mes cases sont case11 case12... les chiffres sont respectivement ligne puis colonne.

Ce que j'ai fais c'est que tout comme tu l'as fais, quand un joueur prend une case une valeur y est affectée (toi tu as pris 1 et 2 et moi 0 et 2 mais bon ça c'est un détail ^^)

et ce que je fais c'est que tout mon morpion est englobé dans un while qui boucle tant que trois cases consécutives ( ex case11 case 12 et case13 mais je vais pas tout te lister car comme tu le sais il y a 8 combinaisons différentes) n'ont pas la même valeur. En effet si une de ces combinaisons ont leur trois cases avec la même valeur cela signifie qu'un joueur a gagné j'ai donc moins de code car je ne teste pas si joueur 1 gagne et si c'est le 2, je teste seulement si il y a une combinaison gagnante et dans ce cas je sors de mon while !

En effet en lisant ton code, tu teste à chaque tour de chaque joueur si il n'a pas gagné moi c'est différent je dis on joue tant qu'il n'y a pas de combinaison gagnante. Ce sont deux approches différentes mais les deux marches (bon la mienne pas trop j'ai pas encore fini de corriger ma condition)

-
Edité par Charles.F 27 mai 2015 à 23:33:17

D'accord, je comprends mieux le principe, c'est plus clair dans ma tête et je vois même possiblement comment améliorer mon code pour une prochaine fois(avec une boucle !). J'ai besoin d'entrainement et de bonnes bases, c'est pas inné chez moi la logique

Il n'y a pas de bonne ou mauvaise solution tant que ça marche c'est bon ! Après c'est sûr qu'avec le temps faudra essayé d'alléger le plus possible nos codes car je suppose qu'ils deviendront énorme mais la au début le but c'est surtout de nous entraîner à manipuler toutes ces commandes de bases pour en faire un programme qui fait ce qu'on lui demande peu importe si tu passes par Lyon pour faire Marseille Paris ou par Clermont Ferrand tant que tu arrives à Paris ! Après faudra effectivement prendre le chemin le plus court mais on à le temps !

Petite envie de faire une métaphore mais que ce passe-t-il dans ma tête !?!? Cours de Français sortez de ce corps !!

salut,

une bonne manière c'est de se souvenir des principes de Descarte concernant l'algorithmique, en particulier :
"decouper toute tache en tache plus simple jusqu'a tomber sur des choses triviales" (c'est SUPER approximatifs mais tu comprend l'idée)...

Donc içi, par exemple, comment savoir que la partie s'arrette ? Si la partie est gagné ou qu'il y a match nul.
Ecrit donc une fonction partie_finie qui verifierait si un des joueurs a gagné ou si il y a match nul.
Le cas de la partie fini est reglé si tu arrive a trouvé si un des joueurs a gagné (donc une autre fonction s'occupera de ca) ou si il y a match nul (une autre fonction)...

Tu vois ou je veux en venir ? A chaque fois qu'une tache est pas déilement simple, tu dois creer une fonction qui la gère.

Bon je viens de refaire ta fonction remplir mais en utilisant des switchs et ça donne ça:

void remplir (int array[], int colonne, int ligne, int joueur, char string[])
{
    switch(joueur)
        {
            case 1:
            switch(colonne)
                {
                    case 1:
                    switch(ligne)
                        {
                            case 1:
                            array[0] = 1;
                            string[0] = 'X';
                            break;
                            case 2:
                            array[3] = 1;
                            string[6] = 'X';
                            break;
                            case 3:
                            array[6] = 1;
                            string[12]='X';
                        }
                    case 2:
                    switch(ligne)
                        {
                            case 1:
                            array[1] = 1;
                            string[2] = 'X';
                            break;
                            case 2:
                            array[4] = 1;
                            string[8] = 'X';
                            break;
                            case 3:
                            array[7] = 1;
                            string[14] = 'X';
                            break;
                        }
                    case 3:
                    switch(ligne)
                        {
                            case 1:
                            array[2] = 1;
                            string[4] = 'X';
                            break;
                            case 2:
                            array[5] = 1;
                            string[10] = 'X';
                            break;
                            case 3:
                            array[8] = 1;
                            string[16] = 'X';
                            break;
                        }
                }
            break;
            case 2:
            switch(colonne)
                {
                    case 1:
                    switch(ligne)
                        {
                            case 1:
                            array[0] = 2;
                            string[0] = 'O';
                            break;
                            case 2:
                            array[3] = 2;
                            string[6] = 'O';
                            break;
                            case 3:
                            array[6] = 2;
                            string[12]='O';
                        }
                    case 2:
                    switch(ligne)
                        {
                            case 1:
                            array[1] = 2;
                            string[2] = 'O';
                            break;
                            case 2:
                            array[4] = 2;
                            string[8] = '0';
                            break;
                            case 3:
                            array[7] = 2;
                            string[14] = 'O';
                            break;
                        }
                    case 3:
                    switch(ligne)
                        {
                            case 1:
                            array[2] = 2;
                            string[4] = 'O';
                            break;
                            case 2:
                            array[5] = 2;
                            string[10] = 'O';
                            break;
                            case 3:
                            array[8] = 2;
                            string[16] = 'O';
                            break;
                        }
                }
            break;
        }
}

Au final ça fait 110 lignes de codes alors que avec tout tes else if tu en avait que 93 ta méthode était donc plus compacte dans ce cas précis. Du coup je suis un peu deg te mettre tout retaper à la main pour que au final ce soit moins bien 

-
Edité par Charles.F 28 mai 2015 à 0:15:32

ok les gars, c'est un début, mais faut apprendre dès le début quelles sont les infos SUFFISANTE pour notre programme.
Un plateau de morpion, c'est quoi ? C'est une tableau carré de 9 cases. Il y a 3 possibilité pour chaque case, soit :

1 - la case est a aucun des deux joueurs
2 - la case est au joueur 1
3 - la case est au joueur 2.

ce qui fait qu'une "case" a 3 états, et qu'un plateau est un tableau de 9 "cases"... du coup, on peut faire :

typedef enum {
  VIDE, J1, J2
} Case;

et le plateau c'est simplement

Case plateau[3][3]; // un tableau de 3*3 cases

Bon, on a déja de quoi stocker notre plateau en entier. Maintenant comment l'afficher ?
Supposons que le joueur 1 c'est les X et le joueur 2 les O. Pour afficher une case, il suffit d'afficher 'X' si la case est de J1, 'O' si elle est de J2, ' ' si elle est vide. Du coup, on obtiens la fonction suivante :

void afficher_case (Case c) {
   if (c == VIDE) printf (" ");
   if (c == J1)   printf ("X");
   if (c == J2)   printf ("O");
}

maintenant qu'on sait afficher une case, on sait afficher tout le plateau : il suffit d'afficher, ligne par ligne, toutes les cases :

void afficher_plateau (Case plateau[][]) { // plateau = tableau de 3 * 3 cases
   for (int i=0; i<3; i++) { // pour toutes les lignes
       for (int j=0; j<3; j++) { // pour toutes les colonnes
           afficher_case (plateau[i][j]); // afficher
       }
       printf ("\n"); // retourner a la ligne
   }
   printf ("\n"); // retourner a la ligne
}

et voila : comme on a découpé notre fonction, on passe de 100 a 17 lignes, et on a economisé un tableau de caractère.

C'était l'affichage, mais presque toutes les parties un peu lourde de vos codes peuvent être allégés comme ca, voir un peu plus. J'espère ne pas avoir maché tout le boulot, mais c'était pour vous montrer a quel point c'est important de bien reflechir sur le pourquoi du comment (et que NON, c'est pas parce que ca marche que c'est forcement une bonne manière de faire )

Courage les gars, ca va venir

-
Edité par bigbrother1 28 mai 2015 à 0:47:17

En poursuivant sur le post de bigbrother, pour faire tes comparaisons pour savoir si un joueur a gagné, tu peux faire nettement mieux qu'un switch. Tu dois vérifier 3 lignes, 3 colonnes et 2 diagonales. Moi ça me fait penser à des boucles. Boucle se sera donc !

int verif_valeurs(int case_1, int case_2, int case_3) {
    if (case_1 == case_2 && case_2 == case_3) {
        return case_1;
    }
    return VIDE;
}

int resultat_partie(int *array) {
    int i;

    // on vérifie les lignes
    for (i = 0; i < 3; i++) {
        int c = verif_valeurs(array[i * 3], array[i * 3 + 1], array[i * 3 + 2]);

        if (c == J1 || c == J2)
            return c;
    }
    // on vérifie les colonnes
    for (i = 0; i < 3; i++) {
        int c = verif_valeurs(array[i], array[i + 3], array[i + 6]);
        if (c == J1 || c == J2)
            return c;
    }
    // on vérifie les diagonales
    int c = verif_valeurs(array[0], array[4], array[8]);
    if (c == J1 || c == J2)
        return c;
    int c = verif_valeurs(array[2], array[4], array[6]);
    if (c == J1 || c == J2)
        return c;
    return VIDE;
}

C'est tout de même nettement plus lisible qu'un switch !

Bonjour,

Deux petits exemples pour améliorer la mise en page et rendre le code plus simple :

void choix(int *colonne, int *ligne)
{
    do {
        printf("\n\tChoisissez une colonne : ");
        scanf("%d", colonne);

        printf("\n\tChoisissez une ligne : ");
        scanf("%d", ligne);

    } while (*colonne > 3 || *colonne < 1 || *ligne > 3 || *ligne < 1);
}

char morpion[] =
    "_|_|_\n"
    "_|_|_\n"
    " | | ";

Merci pour tous ces conseils, je sens que je vais encore galérer pas mal pour alléger mes codes, mais au moins j'ai des pistes pour mieux faire maintenant, encore merci !