.gitignore

+*.o
+sokoban
+unittest
+minunit.h
+suvegardedesfonctioin.c
+**/html
+**/latex
\ No newline at end of file

Makefile

+
+CFLAGS=-Wall -Wextra
+
+
+clean_all : 
+	rm -f sokoban unittest *.o
+
+all: build unittest
+
+build: sokoban
+
+test: unittest
+	@./unittest
+
+distrib:
+	tar -zcvf Arnaud_Albiez.tar.gz main.c grid.c grid.h Makefile
+
+clean :
+	rm -f sokoban *.o 
+
+doc : 
+	doxygen
+
+main.o : main.c grid.h
+	gcc -c $(CFLAGS) main.c 	
+
+grid.o : grid.c grid.h
+	gcc -c $(CFLAGS) grid.c
+
+player.o : player.c player.h
+	gcc -c $(CFLAGS) player.c
+
+sokoban : main.o grid.o player.o
+	gcc -o sokoban main.o grid.o player.o
+
+test.o : test.c grid.h player.h
+	gcc -c test.c
+
+unittest : test.o grid.o player.o
+	gcc -o unittest test.o grid.o player.o

grid.c

 #include "grid.h"
-#include <stdlib.h>
 #include <stdio.h>
+#include <stdlib.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->col = 0;
+  player->row = 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->col = current_column;
+        grid->position->row = 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) {
+  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->col == j && grid->position->row == 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 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);
-	int current_row = 0;
-	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'){
-			current_column += 1;
-			buffer += 1;
-		}		
-		current_row += 1;
-	}
-	// fermeture du fichier
-	fclose(file);
+void free_grid(struct Grid *grid) {
+  free(grid->game_grid);
+  free(grid->tabGoal);
+  free(grid->position);
+  free(grid);
 }

grid.h

 #ifndef GRID_HEADER
 #define GRID_HEADER
-enum CaseType{
-	WALL = '#',
-	BOX = '$',
-	PLAYER = '@',
-	GOAL = '.',
-	NONE = ' '
+#include "player.h"
+enum CaseType { WALL = '#', BOX = '$', PLAYER = '@', GOAL = '.', NONE = ' ' };
+
+struct Goal {
+  int x, y;
 };
+
 /**
  * @struct Grid grid.h
- * @brief Cette structure contient les informations 
+ * @brief Cette structure contient les informations
  * concernant la grille du jeu et son contenu
  */
-struct Grid{
-	enum CaseType** game_grid; ///< Tableau contenant les entités présents dans le jeu
-	int column_number; ///< Nombre de colonne de game_grid
-	int row_number; ///< Nomber de ligne de game_grid
+struct Grid {
+  enum CaseType
+      *game_grid;    ///< Tableau contenant les entités présents dans le jeu
+  int column_number; ///< Nombre de colonne de game_grid
+  int row_number;    ///< Nomber de ligne de game_grid
+  struct Player *position; ///< Positioin du joueur
+  struct Goal *tabGoal;    ///< Liste des but
+  int number_goal;         ///< nombre de goal
 };
-void init_level(const char* file_path);
+
+int coordonner_vers_indice(int x, int y, struct Grid *grid);
+
+enum CaseType *init_grid(int x, int y);
+
+struct Player *init_player();
+
+struct Grid *new_grid(int x, int y);
+
+struct Grid *init_level(const char *file_path);
+
+enum CaseType get_grid(struct Grid *grid, int x, int y);
+
+int get_goal(struct Grid *grid, int x, int y);
+
+void Affichage_grid(struct Grid *grid);
+
+void change_cell_grid(struct Grid *grid, int x, int y,
+                      enum CaseType new_valeur);
+
+void free_grid(struct Grid *grid);
 
 #endif

main.c

@@ -2,16 +2,35 @@
 #include "grid.h"
 #include <stdbool.h>
 int main(void){
-	
+	struct Grid* grid = init_level("./level1.txt");
 	bool run = true;
 	while(run){
+		Affichage_grid(grid);
 		char entry = fgetc(stdin);
 		switch(entry){
-			case 'q' :{
+			case 'e' :{
 				run = false;
 				break;
 			}
+			case 'z' :{
+				move_player(grid, TOP);
+				break;
+			}
+			case 's' :{
+				move_player(grid, BOTTOM);
+				break;
+			}
+			case 'q' :{
+				move_player(grid, LEFT);
+				break;
+			}
+			case 'd' :{
+				move_player(grid, RIGHT);
+				break;
+			}
+
 		}
 	}
+	free_grid(grid);
 }
 

player.c

+#include "player.h"
+#include "grid.h"
+
+void move_player(struct Grid* grid, enum Direction direction){
+    switch(direction){
+		case TOP :{
+            if(get_grid(grid, grid->position->col, grid->position->row-1) == NONE){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->row =-1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col, grid->position->row-1) == GOAL){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->row =-1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col, grid->position->row-1) == BOX){
+                if(get_grid(grid, grid->position->col, grid->position->row-2) != WALL){
+                    change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                    grid->position->row =-1;
+                    change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+                    change_cell_grid(grid, grid->position->col, grid->position->row-1, BOX);
+                }
+                else{return;}
+			break;
+            }
+		}
+        case BOTTOM :{
+			if(get_grid(grid, grid->position->col, grid->position->row+1) == NONE){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->row =+1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col, grid->position->row+1) == GOAL){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->row =+1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col, grid->position->row+1) == BOX){
+                if(get_grid(grid, grid->position->col, grid->position->row+2) != WALL){
+                    change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                    grid->position->row =+1;
+                    change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+                    change_cell_grid(grid, grid->position->col, grid->position->row+1, BOX);
+                }
+			break;
+            }
+		}
+        case LEFT :{
+			if(get_grid(grid, grid->position->col-1, grid->position->row) == NONE){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->col =+1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col+1, grid->position->row) == GOAL){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->col =+1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col+1, grid->position->row) == BOX){
+                if(get_grid(grid, grid->position->col+2, grid->position->row) != WALL){
+                    change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                    grid->position->col =+1;
+                    change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+                    change_cell_grid(grid, grid->position->col+1, grid->position->row, BOX);
+                }
+                else{return;}
+			break;
+            }
+		}
+
+        case RIGHT :{
+            if(get_grid(grid, grid->position->col-1, grid->position->row) == NONE){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->col =-1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col-1, grid->position->row) == GOAL){
+                change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                grid->position->col =-1;
+                change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+            }
+            else if(get_grid(grid, grid->position->col-1, grid->position->row) == BOX){
+                if(get_grid(grid, grid->position->col-2, grid->position->row) != WALL){
+                    change_cell_grid(grid, grid->position->col, grid->position->row, NONE);
+                    grid->position->col =-1;
+                    change_cell_grid(grid, grid->position->col, grid->position->row, PLAYER);
+                    change_cell_grid(grid, grid->position->col-1, grid->position->row, BOX);
+                }
+                else{return;}
+			break;
+            }
+		}
+	}
+    return;
+}
\ No newline at end of file

player.h

+#ifndef __PLAYER_H
+#define __PLAYER_H
+
+struct Grid;
+
+enum Direction{
+    TOP = 'z',
+    LEFT = 'q',
+    RIGHT = 'd',
+    BOTTOM = 's'
+};
+
+struct Player{
+    int col, row;
+};
+
+void move_player(struct Grid* grid, enum Direction direction);
+
+#endif
\ No newline at end of file

test.c

+#include "cester.h"
+#include <stdio.h>
+#include "grid.h"
+#include "player.h"
+
+
+
+CESTER_TEST(test_grid_get_cell, grid,
+    {
+        struct Grid* grid = new_grid(5, 5);
+        for(int x = 0; x < 5; ++x) {
+            for(int y = 0; y < 5; ++y) {
+                cester_assert_equal(NONE, get_grid(grid, x, y));                
+            }
+        }
+    }
+)
+
+CESTER_TEST(test_grid_change_cell, grid,
+    {
+        struct Grid* grid = new_grid(5, 5);
+        change_cell_grid(grid, 1, 2, GOAL);
+        Affichage_grid(grid);
+        cester_assert_equal(GOAL, get_grid(grid, 1, 2));  
+    }
+)
+
+CESTER_TEST(test_move_direction, grid,
+    {
+        struct Grid* grid = init_level("./level1.txt");
+        Affichage_grid(grid);
+        move_player(grid, TOP);
+        Affichage_grid(grid);
+        cester_assert_equal(PLAYER, get_grid(grid, 11, 5));
+    }
+
+)
+
+