Othello/src/jeu.c

#include "../includes/plateau.h"

Jeton *ajoute_jeton(int pos_i, int pos_j, int couleur) {
    Jeton *jeton = malloc(sizeof(Jeton));
    jeton->couleur = couleur;
    jeton->pos_i = pos_i;
    jeton->pos_j = pos_j;

    return jeton;
}

Joueur *nouveau_joueur(int pion) {
    Joueur *joueur = malloc(sizeof(Joueur));
    joueur->nom = pion == NOIR ? "NOIR" : "BLANC";
    joueur->couleur = pion;
    joueur->liste_jeton = nouvelle_liste();
    joueur->nb_jeton = 0;

    return joueur;
}

Jeu *nouvelle_partie(void) {
    Jeu *jeu = malloc(sizeof(Jeu));
    jeu->j1 = nouveau_joueur(NOIR);
    jeu->j2 = nouveau_joueur(BLANC);

    remplissage_debut(jeu);

    return jeu;
}

void deroulement_partie(Jeu *jeu) {
    int tour = NOIR;

    while (!partie_finie(jeu)) {
        affiche_plateau(jeu->plateau);

        if (action_possible_joueur(jeu->plateau, tour)) {
            // Si le joueur peut jouer
            action_joueur_humain(jeu, tour);
        } else {
            printf("Pas de coup jouable.\n");
        }

        tour = tour == NOIR ? BLANC : NOIR;
    }

    int resultat[3];
    if (selection_gagnant(jeu, resultat)) {
        printf("Fin de partie ! Le joueur %c a gagné %d contre %d !\n",
               resultat[0], resultat[1], resultat[2]);
    } else {
        printf("Égalité parfaite, %d contre %d !\n", jeu->j1->nb_jeton,
               jeu->j2->nb_jeton);
    }
}

int jeu_joueur(Jeu *jeu, int case_i, int case_j, int couleur) {
    // TODO
    (void)jeu, (void)case_i, (void)case_j, (void)couleur;

    return 0;
}

int action_possible_joueur(Jeton *plat[LONGEUR][LARGEUR], int couleur) {
    // TODO (enhancement): Instead of returning if the player can play, return a
    // structure with: if the player can play, and the possible moves of the
    // player
    for (int i = 0; i < LONGEUR; i++) {
        for (int j = 0; j < LARGEUR; j++) {
            if (case_jouable(plat, i, j, couleur)) {
                return 1;
            }
        }
    }

    return 0;
}

void _action_joueur_humain(int *ligne, int *colonne) {
    // Demande la colonne
    int ok = 0;
    char tmp;
    while (!ok) {
        printf("Quelle colonne voulez-vous placer votre jeton (A-H) ? ");
        scanf(" %1c", &tmp);

        majuscule(&tmp);
        if (!(tmp >= 'A' && tmp <= 'H')) {
            printf("Colonne renseignée invalide.\n");
        } else {
            *colonne = tmp;
            ok = 1;
        }
    }

    // Demande la ligne
    ok = 0, *ligne = 0;
    while (!ok) {
        printf("Quelle ligne voulez-vous placer votre jeton (1-8) ? ");
        scanf(" %1d", ligne);

        if (*ligne < 1 || *ligne > LARGEUR) {
            printf("Ligne renseignée invalide.\n");
        } else {
            ok = 1;
        }
    }
}

void action_joueur_humain(Jeu *jeu, int couleur) {
    printf("Tour de %c !\n", couleur);
    int ligne, colonne;
    _action_joueur_humain(&ligne, &colonne);

    int ok = 0;
    while (!ok) {
        printf("Vous voulez jouer en %c%d... ", colonne, ligne);

        if (!jeu_joueur(jeu, ligne - 1, colonne - 'A', couleur)) {
            printf("mais ce n'est pas possible, réessayez !\n");

            _action_joueur_humain(&ligne, &colonne);
        }
    }
}

int partie_finie(Jeu *jeu) {
    return ((!action_possible_joueur(jeu->plateau, NOIR)) &&
            (!action_possible_joueur(jeu->plateau, BLANC))) ||
           plateau_rempli(jeu->plateau);
}

int selection_gagnant(Jeu *jeu, int *resultat) {
    if (jeu->j1->nb_jeton == jeu->j2->nb_jeton) {
        // Si égalité
        return 0;
    }

    if (jeu->j1->nb_jeton > jeu->j2->nb_jeton) {
        // Si le joueur 1 a gagné
        resultat[0] = jeu->j1->couleur;
        resultat[1] = jeu->j1->nb_jeton;
        resultat[2] = jeu->j2->nb_jeton;
    } else {
        // Si le joueur 2 a gagné
        resultat[0] = jeu->j2->couleur;
        resultat[1] = jeu->j2->nb_jeton;
        resultat[2] = jeu->j1->nb_jeton;
    }

    return 1;
}

void free_jeu(Jeu *jeu) {
    free_liste(jeu->j1->liste_jeton);
    free(jeu->j1);

    free_liste(jeu->j2->liste_jeton);
    free(jeu->j2);

    for (int i = 0; i < LONGEUR; ++i) {
        for (int j = 0; j < LARGEUR; ++j) {
            free(jeu->plateau[i][j]);
        }
    }

    free(jeu);
}