grid.c

/**
 * @file grid.c
 * @author Efe ERKEN (efe.erken@etu.unistra.fr)
 * @brief Fichier source contenant les fonctions pour traiter les niveaux du jeu sokoban
 * @version 0.1
 * @date 2022-11-10
 *
 * @copyright Copyright (c) 2022
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <ncurses.h>
#include "grid.h"
#include "player.h"

/**
 * @brief Fonction qui alloue la grille du jeu
 *
 * @param [in] row Le nombre de lignes du niveau de jeu
 * @param [in] column Le nombre de colonnes du niveau de jeu
 * @return grid*
 *
 * @pre -
 * @post -
 *
 * Cette fonction prend en paramètre deux arguments tels que le nombre de lignes
 * et le nombre de colonnes du niveau de jeu. Elle alloue dynamiquement la structure @c grid
 * en fonction de cette taille et renvoie un pointeur sur cette structure.
 */
grid *creer_level(int row, int column)
{
    // on alloue la structure elle-même dynamiquement
    grid *G = (grid *)malloc(sizeof(grid));
    // on vérifie si l'allocation s'est bien passée
    if (G == NULL)
    {
        fprintf(stderr, "Error game structure alloc failed");
        exit(-1);
    }
    // on alloue la première dimension du tableau dynamique à deux dimensions dans la structure
    G->game_grid = (enum CaseType **)(malloc(row * (sizeof(enum CaseType *))));
    // on vérifie si l'allocation s'est bien passée
    if (G->game_grid == NULL)
    {
        fprintf(stderr, "Error game_grid row alloc failed");
        exit(-1);
    }
    // on alloue la deuxième dimension du tableau dynamique
    for (int i = 0; i < row; i++)
    {
        G->game_grid[i] = (enum CaseType *)(malloc(column * (sizeof(enum CaseType))));
        // on vérifie si l'allocation s'est bien passée
        if (G->game_grid[i] == NULL)
        {
            fprintf(stderr, "Error game_grid column alloc failed");
            exit(-1);
        }
    }
    // on initialise les valeurs de taille du niveau
    G->row_number = row;
    G->column_number = column;
    return G;
}

/**
 * @brief Fonction pour désallouer la structure du jeu
 *
 * @param [in] G Pointeur sur une structure @c grid
 *
 * @pre @a G doit être non @c NULL et pointer sur la structure allouée
 * @post @a G contient toujours l'adresse qu'il avait
 *
 * Cette fonction prend en paramètre un pointeur sur une structure @c grid
 * et désalloue cette structure. Pour cela dans un premier temps, elle
 * désalloue le tableau dynamique à deux dimensions @a game_grid et finalement
 * elle désalloue la structure elle-même.
 */
void free_level(grid *G)
{
    // on désalloue la deuxième dimension du tableau dynamique dans la structure
    for (int i = 0; i < G->row_number; i++)
    {
        free(G->game_grid[i]);
    }
    // on désalloue la première dimension du tableau dynamique
    free(G->game_grid);
    // on désalloue la structure
    free(G);
}

/**
 * @brief Fonction qui charge le niveau de jeu depuis un fichier dans la structure @c grid
 *
 * @param [in] file_path La localisation du fichier à lire
 * @return grid*
 *
 * @pre -
 * @post -
 *
 * Cette fonction lit ligne par ligne le fichier donné en paramètre pour charger
 * les informations sur le niveau dans la structure @c grid qu'elle alloue elle-même.
 * À part les informations sur par exemple la taille du niveau, elle charge chaque
 * case du niveau dans le tableau dynamique à deux dimension de la structure.
 * Elle recopie le niveau dans une structure et renvoi un pointeur dessus.
 */
grid *init_level(const char *file_path)
{
    // ouverture du fichier en mode lecture
    FILE *file = fopen(file_path, "r");
    // vérification si le fichier est bien ouvert
    if (!file)
    {
        fprintf(stderr, "Error %s not found", file_path);
        exit(-1);
    }
    char line[100] = {0}; // buffer pour lire une ligne dans le fichier
    int number_column = 0; // nombre de colonne
    int number_row = 0; // nombre de ligne
    int number_goals = 0; // nombre d'objectifs
    // on lit la première ligne du fichier
    fgets(line, 100, file);
    // on récupère les informations sur le niveau depuis la première ligne
    sscanf(line, "%d %d %d", &number_column, &number_row, &number_goals);

    // on alloue la structure pour stocker le niveau
    grid *level = creer_level(number_row, number_column);

    int current_row = 0; // la ligne où on se trouve actuellement en lisant le niveau
    // int current_goal = 0;
    // On lit le fichier ligne par ligne jusqu'à la fin du fichier
    while (fgets(line, 100, file) != NULL)
    {
        char *buffer = line;
        int current_column = 0; // la colonne où on se trouve actuellement en lisant le niveau
        // tant qu'on arrive pas à une ligne vide ou à la fin d'une ligne, on continue à lire la ligne
        while (*buffer && *buffer != '\n')
        {
            // on charge chaque case dans la structure
            level->game_grid[current_row][current_column] = *buffer;
            // on initialise la position du joueur dans la structure quand on la retrouve
            if (*buffer == '@') {
                level->player.x = current_column;
                level->player.y = current_row;
            }

            current_column += 1;
            buffer += 1;
        }
        current_row += 1;
    }
    // fermeture du fichier
    fclose(file);
    return level;
}

/**
 * @brief Fonction qui affiche le niveau chargé dans le terminal
 *
 * @param [in] G Pointeur sur la structure qui stocke le niveau
 *
 * @pre @a G doit être non @c NULL et pointer sur la structure allouée
 * @post Affichage des caractères
 *
 * Cette fonction parcourt le tableau dans la structure qui stocke les cases du niveau
 * et les affiche chacun. Elle utilise la fonction @c printf() de @c <stdio.h>
 */
void display(grid *G) {
    // on parcourt chaque ligne et colonne du tableau pour afficher le niveau
    for (int row = 0; row < G->row_number; row++) {
        for (int column = 0; column < G->column_number; column++) {
            printf("%c", G->game_grid[row][column]);
        }
        printf("\n");
    }
}

/**
 * @brief Fonction qui affiche le niveau chargé dans le terminal avec @c ncurses
 *
 * @param [in] G Pointeur sur la structure qui stocke le niveau
 *
 * @pre @a G doit être non @c NULL et pointer sur la structure allouée
 * @post Affichage des caractères, appuyez sur 'q' pour quitter
 *
 * Cette fonction affiche le niveau du jeu comme la fonction @c display() mais au
 * contraire elle utilise la bibliothèque @c <ncurses.h> pour ne pas polluer le terminal
 * avec beaucoup d'affichages inutiles et aussi pour présenter une interface plus agréable
 * et professionnel pour le jeu.
 */
void display_ncurses(grid *G) {
    // on initialise <ncurses.h>
    initscr();
    // on efface le buffer d'avant
    clear();
    noecho();
    cbreak();
    printw("Appuyez sur \"q\" pour quitter\n");
    // on parcourt chaque ligne et colonne du tableau pour charger dans le buffer
    for (int row = 0; row < G->row_number; row++) {
        for (int column = 0; column < G->column_number; column++) {
            printw("%c", G->game_grid[row][column]);
        }
        printw("\n");
    }
    // on affiche le buffer, donc le niveau entier
    refresh();
    // on attend jusqu'à ce que l'utilisateur appuie sur la touche 'q' pour quitter
    char quitCar = '\0';
    while (quitCar != 'q') {
        quitCar = (char) getch();
    }
    // on referme <ncurses.h> pour désallouer la mémoire qu'elle utilisait
    endwin();
}