grid.c

Aller à la documentation de ce fichier.

/*
Game level management functions for Sokoban
Copyright (C) 2022, 2023 Efe ERKEN
 
This file is part of Sokoban
 
Sokoban is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
Sokoban is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with Sokoban.  If not, see <https://www.gnu.org/licenses/>.
 
SPDX-License-Identifier: GPL-3.0-or-later
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <ncurses.h>
#include "grid.h"
#include "player.h"
#include "sdl2.h"
 
grid *creer_level(int row, int column, int goals)
{
    // 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\n");
        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\n");
        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\n");
            exit(-1);
        }
    }
    // on initialise les valeurs de taille et d'objectifs du niveau
    G->row_number = row;
    G->column_number = column;
    G->goal_number = goals;
    return G;
}
 
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);
}
 
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\n", 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, number_goals);
 
    int current_row = 0;  // la ligne où on se trouve actuellement en lisant le niveau
    int current_goal = 0; // le nombre d'objectifs déjà réussi du niveau
    // 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 == PLAYER)
            {
                level->player.x = current_column;
                level->player.y = current_row;
            }
            else if (*buffer == BOX_GOAL)
            { // on incrémente à chaque fois on trouve un objectif déjà réussi
                current_goal++;
            }
 
            current_column += 1;
            buffer += 1;
        }
        current_row += 1;
    }
    // on sauvegarde le nombre d'objectifs déjà réussi dans la structure de jeu
    level->box_over_goal_number = current_goal;
    // fermeture du fichier
    fclose(file);
    return level;
}
 
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");
    }
}
 
void display_ncurses_init()
{
    // on initialise <ncurses.h>
    initscr();
    // on efface le buffer d'avant
    clear();
    // on établi les options <ncurses.h> nécessaires
    noecho();
    cbreak();
}
 
void display_ncurses_draw(grid *G)
{
    // on efface le buffer d'avant
    clear();
    // on charge dans le buffer les messages sur comment interagir
    mvprintw(0, 0, "Appuyez sur \"q\" pour quitter");
    mvprintw(1, 0, "Appuyez sur \"h, j, k, l\" pour vous déplacer");
    // on recherche la taille maximale de la fenêtre
    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);
    // on retrouve les coordonnées telles que le niveau soit centré pour commencer l'affichage
    int centerY = (maxY - G->row_number) / 2;
    int centerX = (maxX - G->column_number) / 2;
    // on parcourt chaque ligne et colonne du tableau pour charger dans le buffer
    // on veille à régler le curseur à chaque caractère pour que le niveau soit centré au final
    for (int row = 0, cursorY = centerY; row < G->row_number; row++, cursorY++)
    {
        for (int column = 0, cursorX = centerX; column < G->column_number; column++, cursorX++)
        {
            mvprintw(cursorY, cursorX, "%c", G->game_grid[row][column]);
        }
    }
    // on écarte le curseur pour ne pas être dérangé
    move(2, 0);
    // on affiche le buffer, donc le niveau entier
    refresh();
}
 
char display_ncurses_input()
{
    // on vide d'abord le buffer d'entrée
    nodelay(stdscr, TRUE);
    while ((getch()) != ERR);
    nodelay(stdscr, FALSE);
    // on lit une touche au clavier
    return (char)getch();
}
 
void display_ncurses_input_error()
{
    // on efface le buffer d'avant
    clear();
    // on charge dans le buffer un message d'erreur
    mvprintw(0, 0, "---> Cette touche n'a pas de fonctionnalité");
    // on écarte le curseur pour ne pas être dérangé
    move(1, 0);
    // on affiche le buffer, donc le message d'erreur
    refresh();
    // on donne à l'utilisateur 3 secondes pour lire le message
    napms(3000);
}
 
void display_ncurses_end()
{
    // on referme <ncurses.h> pour désallouer la mémoire qu'elle utilisait
    endwin();
}
 
void display_sdl2(grid *G)
{
    // on choisit la couleur marron pastel pour l'arrière plan
    SDL_SetRenderDrawColor(context.renderer, 130, 125, 85, 255);
    // on dessine toute la fenêtre en marron pastel
    SDL_RenderClear(context.renderer);
    // on calcule la taille des rectangles représentants les cases du jeu
    // pour une fenêtre de taille fixe
    int squareHeight = context.height / G->row_number;
    int squareWidth = context.width / G->column_number;
    // on parcourt toutes les cases du niveau
    for (int row = 0; row < G->row_number; row++)
    {
        for (int column = 0; column < G->column_number; column++)
        {
            enum CaseType current_case = G->game_grid[row][column];
            // on choisit une couleur en fonction du type de la case
            switch (current_case)
            {
            case WALL:
                // couleur marron pastel
                SDL_SetRenderDrawColor(context.renderer, 130, 125, 85, 255);
                break;
            case BOX:
                // couleur jaune pastel
                SDL_SetRenderDrawColor(context.renderer, 180, 135, 85, 255);
                break;
            case PLAYER:
                // couleur bleue pastel
                SDL_SetRenderDrawColor(context.renderer, 100, 115, 130, 255);
                break;
            case GOAL:
                // couleur grise pastel
                SDL_SetRenderDrawColor(context.renderer, 155, 150, 120, 255);
                break;
            case NONE:
                // couleur citron pastel
                SDL_SetRenderDrawColor(context.renderer, 220, 215, 180, 255);
                break;
            case BOX_GOAL:
                // couleur marron foncée pastel
                SDL_SetRenderDrawColor(context.renderer, 95, 60, 25, 255);
                break;
            case PLAYER_GOAL:
                // couleur bleue foncée pastel
                SDL_SetRenderDrawColor(context.renderer, 50, 65, 80, 255);
                break;
            default:
                // couleur rouge
                SDL_SetRenderDrawColor(context.renderer, 255, 0, 0, 255);
            }
            // on crée un rectangle correspondant à la case de taille et de position voulu
            SDL_Rect rect = {.x = column * squareWidth, .y = row * squareHeight, .w = squareWidth, .h = squareHeight};
            // on dessine le rectangle de la case avec la couleur choisie
            SDL_RenderFillRect(context.renderer, &rect);
        }
    }
    // on affiche dans la fenêtre tous ce qu'on a déssiné
    SDL_RenderPresent(context.renderer);
}
 
enum Event event()
{
    enum Event game_event = EVENT_NONE;
    // on demande une entrée à l'utilisateur
    printf("Entrez la direction voulu : ");
    // on lit un caractère de l'entrée
    char entry = (char)fgetc(stdin);
    // on vide le buffer pour la fois prochaine
    while ((fgetc(stdin)) != '\n');
    // on décide de l'événement en fonction de l'entrée
    switch (entry)
    {
    // événement = quitter le jeu si l'entrée est 'q'
    case 'q':
        game_event = EVENT_QUIT;
        break;
    // événement = aller à gauche si l'entrée est 'h'
    case 'h':
        game_event = EVENT_LEFT;
        break;
    // événement = aller en bas si l'entrée est 'j'
    case 'j':
        game_event = EVENT_DOWN;
        break;
    // événement = aller en haut si l'entrée est 'k'
    case 'k':
        game_event = EVENT_UP;
        break;
    // événement = aller à droite si l'entrée est 'l'
    case 'l':
        game_event = EVENT_RIGHT;
        break;
    }
    return game_event;
}
enum Event event_ncurses()
{
    enum Event game_event = EVENT_NONE;
    // on récupère l'entrée au clavier
    char entry = display_ncurses_input();
    // on décide de l'événement en fonction de l'entrée
    switch (entry)
    {
    // événement = quitter le jeu si l'entrée est 'q'
    case 'q':
        game_event = EVENT_QUIT;
        break;
    // événement = aller à gauche si l'entrée est 'h'
    case 'h':
        game_event = EVENT_LEFT;
        break;
    // événement = aller en bas si l'entrée est 'j'
    case 'j':
        game_event = EVENT_DOWN;
        break;
    // événement = aller en haut si l'entrée est 'k'
    case 'k':
        game_event = EVENT_UP;
        break;
    // événement = aller à droite si l'entrée est 'l'
    case 'l':
        game_event = EVENT_RIGHT;
        break;
    // on affiche un message si l'entrée n'est pas définie dans le programme
    default:
        display_ncurses_input_error();
    }
    return game_event;
}
 
enum Event event_sdl2()
{
    enum Event game_event = EVENT_NONE;
    SDL_Event scan_event;
    // on initialise la variable SDL2 pour récupérer l'événement SDL2
    SDL_WaitEvent(&scan_event);
    // événement = quitter le jeu si on ferme la fenêtre
    if (scan_event.type == SDL_QUIT)
    {
        game_event = EVENT_QUIT;
    }
    else if (scan_event.type == SDL_KEYDOWN)
    {
        switch (scan_event.key.keysym.sym)
        {
        // événement = quitter le jeu si l'entrée est q
        case SDLK_q:
            game_event = EVENT_QUIT;
            break;
        // événement = aller à gauche si l'entrée est flèche gauche ou h
        case SDLK_h:
        case SDLK_LEFT:
            game_event = EVENT_LEFT;
            break;
        // événement = aller en bas si l'entrée est flèche basse ou j
        case SDLK_j:
        case SDLK_DOWN:
            game_event = EVENT_DOWN;
            break;
        // événement = aller en haut si l'entrée est flèche haute ou k
        case SDLK_k:
        case SDLK_UP:
            game_event = EVENT_UP;
            break;
        // événement = aller à droite si l'entrée est flèche droite ou l
        case SDLK_l:
        case SDLK_RIGHT:
            game_event = EVENT_RIGHT;
            break;
        }
    }
    return game_event;
}
 
void exit_routine(grid* G) {
    // on referme le système d'affichage de niveau pour désallouer la mémoire qu'il utilisait
    handle_quit();
    // on désalloue la structure qui stockait le niveau
    free_level(G);
}