Debut de lecture dans un fichier de cartes - Avancement sur l'arbre de talents

resources/Maps.txt

+MAP1 10*16
+
+PFMMMFFPPF
+PFFFFFFPPF
+PFPPPFFPPF
+PFPPPFFPPF
+PFPPFFFPPF
+PFMMMFFPPF
+PFMFFFFPPF
+PFMMPFFPPF
+PFPPPFFPPF
+PFPPFFPPFP
+PFFPPFFPPF
+PFFFMFFPPF
+PFPMMFFPPF
+PFMMMFFPPF
+PFFFPFFPPF
+PFPPPPFPPF
\ No newline at end of file

src/carte.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include "carte.h"
 
+
 /*!
 * \file carte.c
 * \brief Fichier contenant le code des fonctions liees aux cartes.
 */
+
+
+/*!
+ * \fn Carte* LireCarte(int num)
+ * \brief La fonction recupere la n-ieme carte dans un fichier et renvoie un pointeur sur la carte cree
+ *
+ * \return Un pointeur sur une tableau de lettres.
+ */
+char* LireCarte(const char *filename, int num)
+{
+    FILE* file_map = NULL;
+
+    char char_nb_lignes[2]="",char_nb_colonnes[2]="";
+    int nb_lignes = 0, nb_colonnes = 0, i=0, j=0;
+    char map[10][16];
+
+    file_map = fopen(filename, "r");
+
+    fseek(file_map, 5, SEEK_SET);
+    (fgets(char_nb_lignes,3,file_map));
+    nb_lignes = atoi(char_nb_lignes);
+    fseek(file_map, 1, SEEK_CUR);
+    (fgets(char_nb_colonnes,3,file_map));
+    nb_colonnes = atoi(char_nb_colonnes);
+
+    fseek(file_map, 4, SEEK_CUR);
+
+    char * TableauCarte = NULL;
+    TableauCarte = malloc(nb_colonnes * nb_lignes * sizeof(char));
+
+    for(i=0;i<nb_colonnes;i++)
+    {
+        for(j=0;j<=nb_lignes;j++)
+        {
+            TableauCarte[nb_lignes*i+j]=fgetc(file_map);
+        }
+    }
+
+    fclose(file_map);
+    return TableauCarte;
+}

src/carte.h

@@ -3,10 +3,14 @@
 * \brief Fichier contenant les signatures des fonctions liees a la structure carte.
 */
 
+char* LireCarte(const char *filename, int num);
+
 
 #ifndef CARTE_H_INCLUDED
 #define CARTE_H_INCLUDED
 
+#include "structures.h"
+
 
 
 #endif // CARTE_H_INCLUDED

src/competence.c

@@ -22,6 +22,65 @@ typedef struct Competence{
 
 */
 
+/* Arbre manuel */
+Competence comp_1;
+Competence comp_11;
+Competence comp_12;
+Competence comp_111;
+Competence comp_112;
+Competence comp_121;
+
+/*!
+ * \fn int set_Enfant(Competence *parent, Competence *enfant)
+ * \brief La fonction ajoute un enfant à une competence.
+ *
+ * \return Un entier.
+ */
+int set_Enfant(Competence *parent, Competence *nouvel_enfant)
+{
+    if(estVide(parent))
+    {
+        parent->enfant = nouvel_enfant;
+    }else{
+        Competence *enfant = parent->enfant;
+        while(enfant!=NULL)
+        {
+            enfant = enfant->frere;       // A FINIR
+        }
+        enfant->frere = nouvel_enfant;
+
+    }
+    return 0;
+}
+
+
+
+/*!
+ * \fn int init_Competence(Competence *noeud)
+ * \brief La fonction initialise une competence.
+ *
+ * \return Un entier.
+ */
+int init_Competence(Competence *noeud)
+{
+    noeud->nomComp[0] = '\0';
+    noeud->id[0] = '\0';
+    noeud->prix_competence = 0;
+    noeud->frere = NULL;
+    noeud->enfant = NULL;
+    noeud->effet = NULL;
+
+    return 0;
+}
+
+
+
+/*!
+ * \fn int taille(Competence *noeud)
+ * \brief La fonction renvoie le nombre d'enfants totaux d'une competence.
+ *
+ * \return Un entier positif.
+ */
 int taille(Competence *noeud)
 {
     Competence *enfant;
@@ -31,6 +90,13 @@ int taille(Competence *noeud)
     return compteur;
 }
 
+
+/*!
+ * \fn unsigned int hauteur(Competence *noeud)
+ * \brief La fonction indique la hauteur d'une competence dans l'arbre.
+ *
+ * \return Un entier positif.
+ */
 unsigned int hauteur(Competence *noeud)
 {
     if (!estVide(noeud))
@@ -48,6 +114,12 @@ unsigned int hauteur(Competence *noeud)
     }
 }
 
+/*!
+ * \fn int estVide(Competence *c)
+ * \brief La fonction indique si une competence n'a pas d'enfants.
+ *
+ * \return Un booleen.
+ */
 int estVide(Competence *c)
 {
     if (c->enfant == NULL)
@@ -56,12 +128,25 @@ int estVide(Competence *c)
         return 1;
 }
 
+
+/*!
+ * \fn boolean est_connue(Competence *c)
+ * \brief La fonction indique si une competence est connue ou non.
+ *
+ * \return Un booleen.
+ */
 boolean est_connue(Competence *c)
 {
     return (c->connu);
 }
 
 
+/*!
+ * \fn unsigned int * NbEnfants(Competence *noeud)
+ * \brief La fonction renvoie le nombre d'enfants d'une competence.
+ *
+ * \return Un entier positif.
+ */
 unsigned int NbEnfants(Competence *noeud)
 {
     unsigned int nb;
@@ -93,9 +178,21 @@ int rafraichir_competences(Competence * a){
 
 
 
-
-boolean est_complet(Competence *a){
-    return 0;
+/*!
+ * \fn boolean * est_complet(Competence *noeud)
+ * \brief La fonction verifie si l'arbre est complet ou non.
+ *
+ * \return Un booleen.
+ */
+boolean est_complet(Competence *noeud)
+{
+    Competence *enfant;
+    for(noeud->enfant; enfant!= NULL; enfant=enfant->frere)
+    {
+        if(!est_complet(enfant))
+            return 0;
+    }
+    return 1;
 }
 
 int chemin_auto_competence(Competence* c){      /* Renvoie la liste des compétences non connues se trouvant sur le chemin d'une compétence sélectionnée */

src/competence.h

@@ -8,6 +8,8 @@
 
 /* Fonctions */
 
+int init_Competence(Competence *noeud);
+
 int taille(Competence *noeud);
 
 unsigned int NbEnfants(Competence *noeud);

src/main.c

@@ -6,6 +6,7 @@
 #include "terrain.h"
 #include "SDL.h"
 #include "roxml.h"
+#include "carte.h"
 
 int init_jeu(const char *filename){ /* cre les diffrents types de terrains, de classes et d'attaques en lisant dans un fichier */
    FILE *fichier_init;
@@ -62,14 +63,20 @@ int init_jeu(const char *filename){ /* cr
 
 
 
+
 int main()
 {
 
 
+init_jeu("../resources/Init_jeu.xml");
+
+/* Pour Henri <3 */
+/*
+printf("La case choisie est : %c\n",LireCarte("../resources/Maps.txt",0)[50]);
+*/
 
- init_jeu("../resources/Init_jeu.xml");
 
-    main_SDL();
+main_SDL();