-
Sanchez Alexandre authoredSanchez Alexandre authored
competence.c 9.02 KiB
#include <stdio.h>
#include <stdlib.h>
#include <roxml.h>
#include "structures.h"
#include "competence.h"
/*!
* \file competence.c
* \brief Fichier contenant le code des fonctions liees aux arbres de compétences.
*/
/*! Copie de la struct Competence pour travailler
typedef struct Competence{
char nomComp[TAILLE_NOMS];
char id[TAILLE_ID];
unsigned int prix_competence;
struct Competence *frere;
struct Competence *enfant;
struct Effet_Competence *effet;
boolean connu;
}Competence;
*/
/*!
* \fn int init_Competence(Competence *noeud)
* \brief La fonction initialise une competence.
*
* \return Un entier.
*/
Competence* init_Competence(Competence *noeud)
{
noeud = malloc(sizeof(Competence));
memset(noeud->nomComp, 0, sizeof(noeud->nomComp));
memset(noeud->id, 0, sizeof(noeud->id));
noeud->prix_competence = 0;
noeud->frere = NULL;
noeud->enfant = NULL;
noeud->effet = malloc(sizeof(Effet_Competence));
noeud->connu = 0;
return noeud;
}
/* -------------------------------------------------------*/
/* Fonctions de test des competences */
/* -------------------------------------------------------*/
/*!
* \fn int estVide(Competence *c)
* \brief La fonction indique si une competence n'a pas d'enfants.
*
* \return vrai ou faux.
*/
int estVide(Competence *c)
{
return(c->enfant==NULL);
}
/* -------------------------------------------------------*/
/* Fonctions de set des competences */
/* -------------------------------------------------------*/
int set_comp_enfant(Competence *parent, Competence *nouvel_enfant) /* Ne fonctionne pas */
{
if(estVide(parent))
{
init_Competence(parent->enfant);
parent->enfant = nouvel_enfant;
}
else
{
init_Competence(parent->frere);
parent->frere = nouvel_enfant;
/* Ne fonctionne pas */
/*
Competence *enfant_temp;
enfant_temp=init_Competence(enfant_temp);
enfant_temp = parent->enfant;
while(enfant_temp!=NULL)
{
enfant_temp = enfant_temp->frere;
}
enfant_temp->frere = nouvel_enfant;
parent->enfant->frere = nouvel_enfant;
*/
}
return 0;
}
int set_comp_frere(Competence *noeud, Competence *nouveau_frere)
{
noeud->frere = nouveau_frere;
return 0;
}
int set_comp_name(Competence *comp, char *nom_donne)
{
strcpy(comp->nomComp, nom_donne);
return 0;
}
int set_comp_id(Competence *comp, char *nom_donne)
{
strcpy(comp->id, nom_donne);
return 0;
}
int set_comp_prix(Competence *comp, int prix)
{
comp->prix_competence=prix;
return 0;
}
int set_comp_effet(Competence *comp, Effet_Competence *nouvel_effet)
{
comp->effet = nouvel_effet;
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;
int compteur = 1;
for (enfant = noeud->enfant; enfant != NULL; enfant = enfant->frere)
compteur += taille(enfant);
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))
{
int compteur = 1;
Competence *enfant;
for (enfant = noeud->enfant; enfant != NULL; enfant = enfant->frere)
{
if (hauteur(enfant) > compteur)
compteur = 1 + hauteur(enfant);
}
return compteur;
}
else
{
return 0;
}
}
/*!
* \fn boolean est_connue(Competence *c)
* \brief La fonction indique si une competence est connue ou non.
*
* \return vrai ou faux.
*/
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;
if (estVide(noeud))
{
nb = 0;
}
else
{
Competence *enfant;
for(noeud->enfant; enfant!= NULL; enfant=enfant->frere);
nb++;
}
return nb;
}
/*!
* \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 */
{
return 0;
}
Effet_Competence * get_effet(Competence *c) /* Renvoie l'effet d'une competence */
{
return c->effet;
}
Competence* Extraire_Arbres(char *filename)
{
node_t *rootXML, *Arbres;
int nb_Arbres=0, i_0=0;
rootXML = roxml_load_doc(filename);
Arbres = roxml_get_chld(rootXML,"Arbres",0);
nb_Arbres = roxml_get_chld_nb(Arbres);
printf("On a %d arbres de competences \n", nb_Arbres);
/* ---------------------------------------------------------------------------------------------- */
/* Extraction des arbres */
/* ---------------------------------------------------------------------------------------------- */
for(i_0=0; i_0<nb_Arbres; i_0++)
{
node_t *ArbreXML_Actuel = roxml_get_chld(Arbres, NULL, i_0);
Competence *Arbre_Actuel;
int nb_Comp1=0, i_1=0;
init_Competence(Arbre_Actuel);
nb_Comp1 = roxml_get_chld_nb(ArbreXML_Actuel);
printf("L'arbre %d contient %d competences de niveau 1\n",i_0, nb_Comp1);
set_comp_name(Arbre_Actuel,roxml_get_content(roxml_get_attr(ArbreXML_Actuel,"id",0),NULL,0,NULL));
printf("L'arbre actuel a pour nom : %s\n", Arbre_Actuel->nomComp);
/* ---------------------------------------------------------------------------------------------- */
/* Extraction des competences 1 */
/* ---------------------------------------------------------------------------------------------- */
for(i_1=0; i_1<nb_Comp1; i_1++)
{ node_t *CompetenceXML_1;
Competence *Competence_1;
int nb_Comp2=0, i_2=0;
init_Competence(Competence_1);
CompetenceXML_1 = roxml_get_chld(ArbreXML_Actuel, NULL, i_1);
nb_Comp2 = roxml_get_chld_nb(CompetenceXML_1);
printf("La competence numero %d de niveau 1 contient %d competences de niveau 2\n",i_1+1,nb_Comp2);
set_comp_name(Competence_1,roxml_get_content(roxml_get_attr(CompetenceXML_1,"nom",0),NULL,0,NULL));
for(i_2=0; i_2<nb_Comp1; i_2++)
{
}
/* La competence j devient un enfant de la competence i */
set_comp_enfant(Arbre_Actuel, Competence_1);
printf("L'enfant est : %s\n", Arbre_Actuel->enfant->nomComp);
}
}
return 0;
}
int Test_Competences()
{
printf("Debut Test Competences\n");
Competence *Comp_Test_Parent, *Comp_Test_Enfant, *Comp_Test_Petit_Enfant, *Comp_Test_Frere_Enfant;
Comp_Test_Parent=init_Competence(Comp_Test_Parent);
Comp_Test_Enfant=init_Competence(Comp_Test_Enfant);
Comp_Test_Petit_Enfant=init_Competence(Comp_Test_Petit_Enfant);
Comp_Test_Frere_Enfant=init_Competence(Comp_Test_Frere_Enfant);
if(estVide(Comp_Test_Parent)) /* Test de estVide() */
{
printf("Parent n'a pas d'enfants\n");
}
printf("Le nom de parent est : %s\n", Comp_Test_Parent->nomComp); /* Vaut NULL après l'init */
set_comp_prix(Comp_Test_Parent, 4);
set_comp_name(Comp_Test_Parent, "Pepe");
set_comp_id(Comp_Test_Parent, "ID_PE");
printf("Le nom de parent est : %s\n", Comp_Test_Parent->nomComp); /* Vaut bien le nom */
set_comp_name(Comp_Test_Enfant, "Papa");
set_comp_id(Comp_Test_Enfant, "ID_PA");
set_comp_name(Comp_Test_Petit_Enfant, "Bebe");
set_comp_id(Comp_Test_Enfant, "ID_BE");
set_comp_name(Comp_Test_Frere_Enfant, "Tonton");
set_comp_id(Comp_Test_Frere_Enfant, "ID_TON");
/* Tests */
printf("Le prix de Parent est %d\n", Comp_Test_Parent->prix_competence);
printf("Le nom de Parent est %s\n", Comp_Test_Parent->nomComp);
printf("L'ID de Parent est %s\n", Comp_Test_Parent->id);
/* ---- */
set_comp_enfant(Comp_Test_Parent, Comp_Test_Enfant); /* Association Parent-Enfant */
set_comp_enfant(Comp_Test_Parent, Comp_Test_Frere_Enfant); /* Insertion d'un deuxième enfant (qui doit devenir le frère du premier) */
printf("\nL'enfant de %s est %s\n", Comp_Test_Parent->nomComp, Comp_Test_Parent->enfant->nomComp);
printf("L'autre enfant de %s est %s\n", Comp_Test_Parent->nomComp, Comp_Test_Parent->frere->nomComp);
return 0;
}