Correction de TP

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <ctype.h>

#define LARGEUR_DAMIER 7
#define HAUTEUR_DAMIER 6

#define NOMBRE_JOUEURS 2

#define CASE_VIDE ' '
#define CASE_JOUEUR_1 'X'
#define CASE_JOUEUR_2 '0'

#define N 0
#define NE 1
#define E 2
#define ES 3
#define S 4
#define SO 5
#define O 6
#define ON 7

struct case_damier {
    char contenu;
    long index;
    long ligne;
    long colonne;
};

struct curseur {
    struct case_damier * soi;
    struct case_damier * haut;
    struct case_damier * haut_droit;
    struct case_damier * droit;
    struct case_damier * droit_bas;
    struct case_damier * bas;
    struct case_damier * bas_gauche;
    struct case_damier * gauche;
    struct case_damier * gauche_haut;
} curseur;

struct case_damier damier[LARGEUR_DAMIER * HAUTEUR_DAMIER];

struct joueur {
    char humain;
    char symbole;
};

struct joueur joueurs[NOMBRE_JOUEURS];

int nombre_joueurs = sizeof(joueurs) / sizeof(joueurs[0]);
int longueur_damier = sizeof(damier) / sizeof(damier[0]);

int numero_gagnant = 0;


void assigne_curseur(struct case_damier * soi) {

    curseur.haut = NULL;
    curseur.haut_droit = NULL;
    curseur.droit = NULL;
    curseur.droit_bas = NULL;
    curseur.bas = NULL;
    curseur.bas_gauche = NULL;
    curseur.gauche = NULL;
    curseur.gauche_haut = NULL;


    curseur.soi = soi;

    if(soi) {
        if (soi->ligne > 0)
            curseur.haut = &damier[soi->index - LARGEUR_DAMIER];

        if (soi->ligne > 0 && soi->colonne < LARGEUR_DAMIER - 1)
            curseur.haut_droit = &damier[soi->index - LARGEUR_DAMIER + 1];

        if (soi->colonne < LARGEUR_DAMIER - 1)
            curseur.droit = &damier[soi->index + 1];

        if (soi->ligne < HAUTEUR_DAMIER - 1 && soi->colonne < LARGEUR_DAMIER - 1)
            curseur.droit_bas = &damier[soi->index + LARGEUR_DAMIER + 1];

        if (soi->ligne < HAUTEUR_DAMIER - 1)
            curseur.bas = &damier[soi->index + LARGEUR_DAMIER];

        if (soi->ligne < HAUTEUR_DAMIER - 1 && soi->colonne > 0)
            curseur.bas_gauche = &damier[soi->index + LARGEUR_DAMIER - 1];

        if (soi->colonne > 0)
            curseur.gauche = &damier[soi->index - 1];

        if (soi->colonne > 0 && soi->ligne > 0)
            curseur.gauche_haut = &damier[soi->index - LARGEUR_DAMIER - 1];
    }
}

int gagnant() {
    char symbole = '\0';
    for (int i = 0; i < longueur_damier ; ++i) {
        if (damier[i].contenu == CASE_VIDE) continue;

        symbole = damier[i].contenu;

        for (int direction = 0 ; direction < 8 ; direction ++) {
            assigne_curseur(&damier[i]);
            int longueur = 1;
            while(curseur.soi->contenu == symbole) {
                switch (direction) {
                    case N:
                        assigne_curseur(curseur.haut);
                        break;
                    case NE:
                        assigne_curseur(curseur.haut_droit);
                        break;
                    case E:
                        assigne_curseur(curseur.droit);
                        break;
                    case ES:
                        assigne_curseur(curseur.droit_bas);
                        break;
                    case S:
                        assigne_curseur(curseur.bas);
                        break;
                    case SO:
                        assigne_curseur(curseur.bas_gauche);
                        break;
                    case O:
                        assigne_curseur(curseur.gauche);
                        break;
                    case ON:
                        assigne_curseur(curseur.gauche_haut);
                        break;
                    default:
                        assigne_curseur(curseur.haut);
                        break;
                }

                if(curseur.soi == NULL || curseur.soi->contenu != symbole)
                    break;

                if(++longueur == 4) {
                    if(symbole == CASE_JOUEUR_1) return 1;
                    if(symbole == CASE_JOUEUR_2) return 2;
                }
            }
        }
    }

    return 0;
}


void afficher_numeros_ligne(void) {
    for (int j = 1 ; j <= LARGEUR_DAMIER ; ++j) {
        printf("  %d ", j);
    }
    putchar('\n');
}

void afficher_separation_horizontale(void) {
    for (int j = 1 ; j <= LARGEUR_DAMIER ; ++j) {
        printf("+---");
    }
    puts("+");
}

void afficher_damier() {

    int ligne = 1;

    for (typeof(longueur_damier) i = 0 ; i < longueur_damier ; i++) {

        if (i == 0) {
            afficher_numeros_ligne();
            afficher_separation_horizontale();
        }

        printf("| %c ", damier[i].contenu);

        if (((i + 1) % LARGEUR_DAMIER) == 0) {
            puts("|");
            afficher_separation_horizontale();
            ++ligne;
        }
    }
    afficher_numeros_ligne();
}

int choix_ia(struct joueur pJoueur) {
    return 1;
}

int main() {

    char char_rec = '\0';

    joueurs[0].symbole = CASE_JOUEUR_1;
    joueurs[1].symbole = CASE_JOUEUR_2;

    for (typeof(longueur_damier) i = 0 ; i < longueur_damier ; i++) {
        damier[i].contenu = CASE_VIDE;
        damier[i].index = i;
        damier[i].colonne = i % LARGEUR_DAMIER;
        damier[i].ligne = i / LARGEUR_DAMIER;
    }

    afficher_damier();

    for (int i = 0 ; i < nombre_joueurs ; ++i) {

        printf("Joueur %d humain ou ordinateur ? (H/O)\n> ", i + 1);

        scanf(" %c", &char_rec);

        if (tolower(char_rec) == 'h') {
            joueurs[i].humain = '\1';
        }
    }

    struct joueur *joueur_actif = &joueurs[1];
    long colonne_jouee = -1;

    while(!(numero_gagnant = gagnant())) {

        colonne_jouee = -1;
        joueur_actif = (joueur_actif == &joueurs[0]) ? &joueurs[1] : &joueurs[0];

        if (joueur_actif->humain) {
            printf(
                    "Au joueur %ld (%c) de jouer (un chiffre entre 1 et 7)\n> ",
                   ((joueur_actif - &joueurs[0]) + 1),
                   joueur_actif->symbole
            );

            while (1) {
                scanf(" %c", &char_rec);

                if (char_rec >= '1' && char_rec <= '7') {
                    colonne_jouee = strtol(&char_rec, NULL, 10);
                    if(damier[colonne_jouee -1].contenu == CASE_VIDE)
                        break;
                    else {
                        puts("Colonne remplie, veuillez en choisir une autre.");
                    }
                } else {
                    puts("Chiffre invalide.");
                }
            }
        } else {
            colonne_jouee = choix_ia(*joueur_actif);
        }

        assigne_curseur(&damier[colonne_jouee -1]);

        while(curseur.bas != NULL && curseur.bas->contenu == CASE_VIDE)
            assigne_curseur(curseur.bas);

        curseur.soi->contenu = joueur_actif->symbole;

        afficher_damier();

    }

    printf("Le joueur %d (%c) a gagné", numero_gagnant, joueur_actif->symbole);

    return EXIT_SUCCESS;
}