grid.c

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

//

int coordonner_vers_indice(int x, int y, struct Grid* grid)
{
	return((y * grid->column_number)+ x);
}

enum CaseType* init_grid(int x, int y)
{
	size_t taille_grid = x * y;
	enum CaseType* new_grid = (enum CaseType*) malloc(taille_grid * sizeof(enum CaseType));
	for(size_t i = 0; i< taille_grid; i++)
	{
		new_grid[i] = NONE;
	}
	return new_grid;
}

struct Player* init_player()
{
	struct Player * player = (struct Player *) malloc(sizeof(struct Player));	
	player->x = 0;
	player->y = 0;
	return player;
}


struct Grid* new_grid(int x, int y)
{
	struct Grid * new_strut_grid = (struct Grid *) malloc(sizeof(struct Grid));
	new_strut_grid->column_number=x;
	new_strut_grid->row_number= y;
	new_strut_grid->game_grid = init_grid(x, y);
	new_strut_grid->position = init_player();
	new_strut_grid->tabGoal = NULL;
	return new_strut_grid;	
}


struct Grid* init_level(const char* file_path){
	// ouverture du fichier en mode lecture
	FILE* file = fopen(file_path, "r");
	if(!file){
		fprintf(stderr, "Error %s not found", file_path);
		exit(-1);
	}
	char line[100] = {0};
	int number_column = 0; // nombre de colonne
	int number_row = 0; /// nombre de ligne
	int number_goals = 0;
	// on lit la première ligne du fichier
	fgets(line, 100, file);
	sscanf(line, "%d %d %d", &number_column, &number_row, &number_goals);
	struct Grid* grid = new_grid(number_row, number_column);
	int current_row = 0;
	grid->number_goal = number_goals;
	grid->tabGoal = malloc(number_goals * (sizeof(struct Goal)));
	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;
		while(*buffer && *buffer != '\n'){
			if(buffer[0] == '@'){
				grid->position->x = current_column;
				grid->position->y = current_row;
			}
			else if(buffer[0] == '.'){
				grid->tabGoal[current_goal].x = current_column;
				grid->tabGoal[current_goal].y = current_row;
				current_goal =+1;
			}
			else{
				change_cell_grid(grid, current_row, current_column, buffer[0]);
			}
			current_column += 1;
			buffer += 1;
		}		
		current_row += 1;
	}
	// fermeture du fichier
	fclose(file);
	return grid;
}


enum CaseType get_grid(struct Grid* grid, int x, int y)
{
	if (0 <=  x && x <grid->column_number && 0 <= y && y <grid->row_number )
	{
		return grid->game_grid[coordonner_vers_indice(x, y, grid)];
	}
	else{return -1;}
}


int get_goal(struct Grid* grid, int x, int y)
{
	if (0 <=  x && x <grid->column_number && 0 <= y && y <grid->row_number )
	{
		for(int i = 0; i<grid->number_goal; i++)
		{
			if (grid->tabGoal[i].x == x && grid->tabGoal[i].y == y)
			{
				return 1;
			}
		}
		return -1;
	}
	else{
		return -1;
	}
}

void Affichage_grid(struct Grid* grid)
{
	printf("player: %d %d\n", grid->position->x, grid->position->y);
	for(int i = 0; i<grid->column_number; i++)
	{
		for(int j = 0 ; j < grid->row_number; j++)
		{
			switch(get_grid(grid, i, j))
			{
				case NONE :{
					if(grid->position->x == j && grid->position->y == i)
					{
						printf("@");
					}
					else if(get_goal(grid, i, j) == 1)
					{
						printf(".");
					}
					else
					{
						printf(" ");
					}
					break;
				}
				case WALL:{
					printf("#");
					break;
				}
				case BOX:{
					printf("$");
					break;
				}
				case PLAYER:{
					printf("@");
					break;
				}
				case GOAL:{
					printf(".");
					break;
				}
			}
		}
	printf("\n");
	}
}

void change_cell_grid(struct Grid* grid, int x, int y, enum CaseType new_valeur)
{
	grid->game_grid[coordonner_vers_indice(x, y, grid)] = new_valeur;
}

void free_grid(struct Grid* grid)
{
	free( grid->game_grid);
	free(grid->tabGoal);
	free( grid->position);
	free (grid);
}