/* Sauvegarde la position du joueur dans le niveau deja genere */
void sauvegarderPositionJoueurNiveau(void)
{
FILE *position;
char chemin[TAILLE_MAX];
sprintf(chemin, "Sauvegarde/%s/Niveau/position_joueur.txt", personnage.nom);
/* On ouvre le fichier contenant la position du joueur */
position = ouvrirFichier(chemin, "w+",
"fichier \"position_joueur.txt\", fonction \"sauvegarderPositionJoueurNiveau\"");
/* On ecrit la position du joueur */
fprintf(position, "%d\n", personnage.positionJoueur[LIG]);
fprintf(position, "%d\n", personnage.positionJoueur[COL]);
/* On ferme le fichier contenant la position du joueur */
fermerFichier(position,
"fichier \"position_joueur.txt\", fonction \"sauvegarderPositionJoueurNiveau\"");
sprintf(chemin, "Sauvegarde/%s/Niveau/salle_actuelle.txt", personnage.nom);
/* On ouvre le fichier contenant la salle actuelle ou se trouve le joueur */
position = ouvrirFichier(chemin, "w+",
"fichier \"salle_actuelle.txt\", fonction \"sauvegarderPositionJoueurNiveau\"");
/* On ecrit l'index de la salle ou se trouve le joueur */
fprintf(position, "%d\n", niveauActuel.salleActuelle);
/* On ferme le fichier contenant la salle actuelle ou se trouve le joueur */
fermerFichier(position,
"fichier \"salle_actuelle.txt\", fonction \"sauvegarderPositionJoueurNiveau\"");
}
void chargerPositionJoueurNiveau(void)
{
FILE *position;
char chemin[TAILLE_MAX];
sprintf(chemin, "Sauvegarde/%s/Niveau/position_joueur.txt", personnage.nom);
position = ouvrirFichier(chemin, "r",
"fichier \"position_joueur.txt\", fonction \"chargerPositionJoueurNiveau\"");
fscanf(position, "%d\n", &personnage.positionJoueur[LIG]);
fscanf(position, "%d\n", &personnage.positionJoueur[COL]);
fermerFichier(position,
"fichier \"position_joueur.txt\", fonction \"chargerPositionJoueurNiveau\"");
sprintf(chemin, "Sauvegarde/%s/Niveau/salle_actuelle.txt", personnage.nom);
position = ouvrirFichier(chemin, "r",
"fichier \"salle_actuelle.txt\", fonction \"chargerPositionJoueurNiveau\"");
fscanf(position, "%d\n", &(niveauActuel.salleActuelle));
fermerFichier(position,
"fichier \"salle_actuelle.txt\", fonction \"chargerPositionJoueurNiveau\"");
}
/* Sauvegarde les infos de la salle indexSalle (nbCoffre, nbEnnemi, caracteristique ennemi
etc.) */
void sauvegarderInfoSalleIndiviuelleNiveau(const unsigned int indexSalle)
{
FILE *infoSalle, *infoEnnemi;
char chemin[TAILLE_MAX];
compteur indexEnnemi;
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/info_salle.txt", personnage.nom, indexSalle + 1);
/* On ouvre le fichier contenant les infos de la salle */
infoSalle = ouvrirFichier(chemin, "w+",
"fichier \"info_salle.txt\", fonction \"sauvegarderInfoSalleIndiviuelleNiveau\"");
/* On ecrit les infos de la salle */
fprintf(infoSalle, "%d\n", niveauActuel.salle[indexSalle].nbCoffre);
fprintf(infoSalle, "%d\n", niveauActuel.salle[indexSalle].nbEnnemi);
/* On ferme le fichier contenant les infos de la salle */
fermerFichier(infoSalle,
"fichier \"info_salle.txt\", fonction \"sauvegarderInfoSalleIndiviuelleNiveau\"");
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/info_ennemi.txt", personnage.nom, indexSalle + 1);
/* On ouvre le fichier contenant les infos des ennemis de la salle */
infoEnnemi = ouvrirFichier(chemin, "w+",
"fichier \"info_ennemi.txt\", fonction \"sauvegarderInfoSalleIndiviuelleNiveau\"");
/* Pour chaque ennemi */
for(indexEnnemi = 0; indexEnnemi < niveauActuel.salle[indexSalle].nbEnnemi; ++indexEnnemi)
{
/* On ecrit ses caracteristiques */
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].position[LIG]);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].position[COL]);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].nbVie);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].degatAttaque);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].protection);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].porteeAttaque);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].estModeFocus);
fprintf(infoEnnemi, "%d\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].nbTourFocus);
fprintf(infoEnnemi, "%d\n\n", niveauActuel.salle[indexSalle].ennemi[indexEnnemi].nbTourAttendreFocus);
}
/* On ferme le fichier contenant les infos des ennemis de la salle */
fermerFichier(infoEnnemi,
"fichier \"info_ennemi.txt\", fonction \"sauvegarderInfoSalleIndiviuelleNiveau\"");
}
int main(){
FILE* fichier = NULL;
char grille[NBRE_LIGNE][NBRE_COL];
#if MODE
liste_elem tab_hach[9];
liste_elem file_prio;
#else
tab_elem tab_hach[9];
#endif
int sum = 0, i = 0;
fichier = ouvFichier("p096_sudoku.txt", "r+");
for(i=0; i<NBRE_GRILLE; i++){
printf("grille %d\n", i);
lectureGrille(fichier, grille);
file_prio = initTableHachage(grille, tab_hach);
resolutionSudoku(file_prio);
sum = sum + grille[0][0]*100 + grille[0][1]*10+grille[0][2];
liberationFilePrio(&file_prio);
}
printf("result : %d\n", sum);
fermerFichier(fichier);
return 0;
}
int main(int argc, char **argv)
{
FILE *f = NULL;
Reseau *R = creerReseau();
ListeChaine *L = creerListeChaine();
if (argc == 2) {
fprintf(stdout, "Ouverture du fichier %s\n", argv[1]);
f = ouvrirFichier(argv[1]);
}
int choix = -1;
while (choix != 0) {
showMenu();
choix = readNombre();
callChoix(&f, choix, &R, &L);
}
printf("Fermeture en cours\n");
if (f) {
fermerFichier(f);
}
freeReseau(R);
freeListeChaine(L);
return 0;
}
void recupererInformationPersonnage(const char *nomPersonnage)
{
FILE *infoPersonnage;
char chemin[TAILLE_MAX];
sprintf(chemin, "Sauvegarde/%s/detail_personnage.txt", nomPersonnage);
infoPersonnage = ouvrirFichier(chemin, "r",
"fichier \"detail_personnage.txt\", fonction \"recupererInformationPersonnage\"");
lire(infoPersonnage, personnage.nom);
lire(infoPersonnage, personnage.race);
fscanf(infoPersonnage, "%d\n", &(personnage.niveauEXPActuel));
fscanf(infoPersonnage, "%d\n", &(personnage.niveauActuel));
fscanf(infoPersonnage, "%d\n", &(personnage.lvl));
lire(infoPersonnage, personnage.metier);
fscanf(infoPersonnage, "%d\n", &(personnage.sante));
fscanf(infoPersonnage, "%d\n", &(personnage.santeActuelle));
fscanf(infoPersonnage, "%d\n", &(personnage.protection));
fscanf(infoPersonnage, "%d\n", &(personnage.degatParTour));
fscanf(infoPersonnage, "%d\n", &(personnage.attaque.aAttaqueEnnemi));
fscanf(infoPersonnage, "%d\n", &(personnage.attaque.indexEnnemiAttaque));
fermerFichier(infoPersonnage,
"fichier \"detail_personnage.txt\", fonction \"recupererInformationPersonnage\"");
}
/* Sauvegarde la forme de la salle indexSalle */
void sauvegarderFormeSalleIndividuelleNiveau(const unsigned int indexSalle)
{
FILE *salle;
char chemin[TAILLE_MAX];
compteur indexLig, indexCol;
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/salle_%d.txt", personnage.nom, indexSalle + 1, indexSalle + 1);
/* On ouvre le fichier contenant la forme de la salle */
salle = ouvrirFichier(chemin, "w+",
"fichier \"salle\", fonction \"sauvegarderFormeSalleIndividuelleNiveau\"");
/* Pour chaque ligne de la salle */
for(indexLig = 0; indexLig < LARGUEUR_SALLE; ++indexLig)
{
/* Pour chaque colonne de la salle */
for(indexCol = 0; indexCol < LONGUEUR_SALLE; ++indexCol)
{
/* On la sauvegarde dans le fichier */
fprintf(salle, "%c", niveauActuel.salle[indexSalle].mapSalle[indexLig][indexCol]);
}
fprintf(salle, "\n");
}
/* On ferme le fichier contenant la forme de la salle */
fermerFichier(salle,
"fichier \"salle\", fonction \"sauvegarderFormeSalleIndividuelleNiveau\"");
}
/* Sauvegarde les tresors de l'inventaire dans le fichier Inventaire/tresor.txt */
void sauvegarderTresorInventaire(void)
{
FILE *fichierTresor;
char chemin[TAILLE_MAX];
compteur indexTresor;
sprintf(chemin, "Sauvegarde/%s/Inventaire/tresor.txt", personnage.nom);
/* On ouvre le fichier Inventaire/tresor.txt */
fichierTresor = ouvrirFichier(chemin, "w+",
"fichier \"armure.txt\", fonction \"sauvegarderTresorInventaire\"");
/* On ecrit les donnees des tresors avec le nom, et le cout (pour les NB_TRESOR_MAX) */
for(indexTresor = 0; indexTresor < NB_TRESOR_MAX; ++indexTresor)
{
fprintf(fichierTresor, "%s\n", inventaire.tresor[indexTresor].nom);
fprintf(fichierTresor, "%d\n", inventaire.tresor[indexTresor].cout);
}
fprintf(fichierTresor, "%d\n", inventaire.tresorActuel);
/* On ferme le fichier Inventaire/tresor.txt */
fermerFichier(fichierTresor,
"fichier \"armure.txt\", fonction \"sauvegarderTresorInventaire\"");
}
int main(int argc, char **argv) {
FILE *f = NULL;
FILE *output = NULL;
Reseau *R = NULL;
ListeChaine *L = NULL;
char *filename = NULL;
int i;
if (argc < 2) {
leverErreur("Usage : ./convertchaine *.res");
return 1;
}
for (i = 1; i < argc; i++) {
f = ouvrirFichier(argv[i]);
if (f == NULL) {
continue;
}
L = creerListeChaine();
R = creerReseau();
lecture_fichier_reseau(f, R);
recree_liste_chaine(L, R);
filename = basename(argv[i]);
fprintf(stderr, "Conversion en ListeChaine du fichier %s...\n",
argv[i]);
filename = strtok(filename, ".");
filename = strcat(filename, ".cha");
output = fopen(filename, "w");
if (!output) {
leverErreur("Erreur création fichier de sortie");
freeReseau(R);
freeListeChaine(L);
fermerFichier(f);
return 1;
}
ecrit_chaine_txt(L, output);
fermerFichier(output);
fermerFichier(f);
freeReseau(R);
freeListeChaine(L);
}
return 0;
}
/* Sauvegarde la caverne du niveau */
void sauvegarderCaverneNiveau(void)
{
FILE *infoCaverne;
char chemin[TAILLE_MAX];
compteur indexLig, indexEnnemi;
sprintf(chemin, "Sauvegarde/%s/Niveau/Caverne/info_caverne.txt", personnage.nom);
/* On ouvre le fichier contenant toutes les infos sur la caverne */
infoCaverne = ouvrirFichier(chemin, "w+",
"fichier \"info_caverne.txt\", fonction \"sauvegarderCaverneNiveau\"");
/* On ecrit les infos principales sur la caverne */
fprintf(infoCaverne, "%d\n", niveauActuel.salleCaverne);
fprintf(infoCaverne, "%d\n", niveauActuel.estDansCaverne);
/* Si il y a une caverne dans le niveau */
if(niveauActuel.salleCaverne != -1)
{
/* On ecrit les caracteristiques de la caverne (position, forme, ennemi) */
/* Position */
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.directionEntree);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ligDebut);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.colDebut);
/* Forme */
for(indexLig = 0; indexLig < LARGUEUR_SALLE; ++indexLig)
fprintf(infoCaverne, "%s", niveauActuel.salle[niveauActuel.salleCaverne].caverne.mapSalle[indexLig]);
/* Ennemi */
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.nbEnnemi);
for(indexEnnemi = 0; indexEnnemi < niveauActuel.salle[niveauActuel.salleCaverne].caverne.nbEnnemi; ++indexEnnemi)
{
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].position[LIG]);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].position[COL]);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].nbVie);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].degatAttaque);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].protection);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].porteeAttaque);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].estModeFocus);
fprintf(infoCaverne, "%d\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].nbTourFocus);
fprintf(infoCaverne, "%d\n\n", niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].nbTourAttendreFocus);
}
}
/* On ferme le fichier contenant toutes les infos sur la caverne */
fermerFichier(infoCaverne,
"fichier \"info_caverne.txt\", fonction \"sauvegarderCaverneNiveau\"");
}
void chargerInfoSalleIndiviuelleNiveau(const unsigned int indexSalle)
{
FILE *infoSalle, *infoEnnemi;
char chemin[TAILLE_MAX];
compteur indexEnnemi;
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/info_salle.txt", personnage.nom, indexSalle + 1);
infoSalle = ouvrirFichier(chemin, "r",
"fichier \"info_salle.txt\", fonction \"chargerInfoSalleIndiviuelleNiveau\"");
fscanf(infoSalle, "%d\n", &(niveauActuel.salle[indexSalle].nbCoffre));
fscanf(infoSalle, "%d\n", &(niveauActuel.salle[indexSalle].nbEnnemi));
fermerFichier(infoSalle,
"fichier \"info_salle.txt\", fonction \"chargerInfoSalleIndiviuelleNiveau\"");
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/info_ennemi.txt", personnage.nom, indexSalle + 1);
infoEnnemi = ouvrirFichier(chemin, "r",
"fichier \"info_ennemi.txt\", fonction \"chargerInfoSalleIndiviuelleNiveau\"");
for(indexEnnemi = 0; indexEnnemi < niveauActuel.salle[indexSalle].nbEnnemi; ++indexEnnemi)
{
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].position[LIG]));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].position[COL]));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].nbVie));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].degatAttaque));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].protection));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].porteeAttaque));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].estModeFocus));
fscanf(infoEnnemi, "%d\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].nbTourFocus));
fscanf(infoEnnemi, "%d\n\n", &(niveauActuel.salle[indexSalle].ennemi[indexEnnemi].nbTourAttendreFocus));
}
fermerFichier(infoEnnemi,
"fichier \"info_ennemi.txt\", fonction \"chargerInfoSalleIndiviuelleNiveau\"");
}
void recupererNomSauvegarde(char baseNomSauvegarde[NB_SAUVEGARDE][TAILLE_MAX])
{
FILE *fichierSauvegarde;
compteur indexSauvegarde;
fichierSauvegarde = ouvrirFichier("Sauvegarde/nom_sauvegarde.txt", "r",
"fichier \"nom_sauvegarde.txt\", fonction \"recupererNomSauvegarde\"");
for(indexSauvegarde = 0; indexSauvegarde < NB_SAUVEGARDE; ++indexSauvegarde)
lire(fichierSauvegarde, baseNomSauvegarde[indexSauvegarde]);
fermerFichier(fichierSauvegarde,
"fichier \"nom_sauvegarde.txt\", fonction \"recupererNomSauvegarde\"");
}
void sauvegarderCleInventaire(void)
{
FILE *fichierCle;
char chemin[TAILLE_MAX];
sprintf(chemin, "Sauvegarde/%s/Inventaire/cle.txt", personnage.nom);
fichierCle = ouvrirFichier(chemin, "w+",
"fichier \"cle.txt\", fonction \"sauvegarderCleInventaire\"");
fprintf(fichierCle, "%d\n", inventaire.possedeCleFinNiveau);
fermerFichier(fichierCle,
"fichier \"cle.txt\", fonction \"sauvegarderCleInventaire\"");
}
void initialiserCleInventaire(void)
{
FILE *fichierCle;
char chemin[TAILLE_MAX];
sprintf(chemin, "Sauvegarde/%s/Inventaire/cle.txt", personnage.nom);
fichierCle = ouvrirFichier(chemin, "w+",
"fichier \"cle.txt\", fonction \"initialiserCleInventaire\"");
fprintf(fichierCle, "0\n");
fermerFichier(fichierCle,
"fichier \"cle.txt\", fonction \"initialiserCleInventaire\"");
}
int main(int argc, char **argv) {
FILE * f = NULL;
FILE * output = NULL;
Graphe * G = NULL;
char *filename = NULL;
if (argc < 2) {
fprintf(stderr, "usage: %s <gph-files>\n", argv[0]);
return 1;
}
int i;
for (i = 1; i < argc; i++) {
f = ouvrirFichierRead(argv[i]);
G = lectureGraphe(f);
filename = basename(argv[i]);
filename = strtok(filename, ".");
filename = strcat(filename, ".ps");
fprintf(stderr, "Converting %s to %s...\n", argv[i], filename);
output = ouvrirFichierWrite(filename);
writeGraphe(output, G);
fermerFichier(output);
fprintf(stderr, "Done.\n");
freeGraphe(G);
if (f) {
fermerFichier(f);
}
}
fprintf(stderr, "All tasks completed.\n");
return 0;
}
int main(){
unsigned int** matrice = (unsigned int**)allocTab2D(TAILLE_MATRICE, TAILLE_MATRICE, sizeof(unsigned int));
#if MODE
FILE* fichier = ouvFichier("test.txt", "r");
#else
FILE* fichier = ouvFichier("p081_matrix.txt", "r");
#endif
lireMatrice(fichier, matrice, TAILLE_MATRICE, TAILLE_MATRICE);
printf("%d\n", shorterWay(matrice));
liberationTab2D((void**)matrice, TAILLE_MATRICE);
fermerFichier(&fichier);
return 0;
}
void chargerFormeSalleIndividuelleNiveau(const unsigned int indexSalle)
{
FILE *salle;
char chemin[TAILLE_MAX];
compteur indexLig;
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/salle_%d.txt", personnage.nom, indexSalle + 1, indexSalle + 1);
salle = ouvrirFichier(chemin, "r",
"fichier \"salle\", fonction \"chargerFormeSalleIndividuelleNiveau\"");
for(indexLig = 0; indexLig < LARGUEUR_SALLE; ++indexLig)
lire(salle, niveauActuel.salle[indexSalle].mapSalle[indexLig]);
fermerFichier(salle,
"fichier \"salle\", fonction \"chargerFormeSalleIndividuelleNiveau\"");
}
void chargerCaverneNiveau(void)
{
FILE *infoCaverne;
char chemin[TAILLE_MAX];
compteur indexLig, indexEnnemi;
sprintf(chemin, "Sauvegarde/%s/Niveau/Caverne/info_caverne.txt", personnage.nom);
infoCaverne = ouvrirFichier(chemin, "r",
"fichier \"info_caverne.txt\", fonction \"chargerCaverneNiveau\"");
fscanf(infoCaverne, "%d\n", &(niveauActuel.salleCaverne));
fscanf(infoCaverne, "%d\n", &(niveauActuel.estDansCaverne));
if(niveauActuel.salleCaverne != -1)
{
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.directionEntree));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ligDebut));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.colDebut));
for(indexLig = 0; indexLig < LARGUEUR_SALLE; ++indexLig)
lire(infoCaverne, niveauActuel.salle[niveauActuel.salleCaverne].caverne.mapSalle[indexLig]);
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.nbEnnemi));
for(indexEnnemi = 0; indexEnnemi < niveauActuel.salle[niveauActuel.salleCaverne].caverne.nbEnnemi; ++indexEnnemi)
{
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].position[LIG]));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].position[COL]));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].nbVie));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].degatAttaque));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].protection));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].porteeAttaque));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].estModeFocus));
fscanf(infoCaverne, "%d\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].nbTourFocus));
fscanf(infoCaverne, "%d\n\n", &(niveauActuel.salle[niveauActuel.salleCaverne].caverne.ennemi[indexEnnemi].nbTourAttendreFocus));
}
}
fermerFichier(infoCaverne,
"fichier \"info_caverne.txt\", fonction \"chargerCaverneNiveau\"");
}
void lireEtAfficher(const char *chemin)
{
FILE *fichier;
char buffer[TAILLE_MAX];
fichier = ouvrirFichier(chemin, "r",
"fonction \"lireEtAfficher\"");
while(!feof(fichier))
{
fgets(buffer, TAILLE_MAX, fichier);
if(!feof(fichier))
printf("%s", buffer);
}
fermerFichier(fichier,
"fonction \"lireEtAfficher\"");
}
void sauvegarderTresorInventaire(void)
{
FILE *fichierTresor;
char chemin[TAILLE_MAX];
compteur indexTresor;
sprintf(chemin, "Sauvegarde/%s/Inventaire/tresor.txt", personnage.nom);
fichierTresor = ouvrirFichier(chemin, "w+",
"fichier \"armure.txt\", fonction \"sauvegarderTresorInventaire\"");
for(indexTresor = 0; indexTresor < NB_TRESOR_MAX; ++indexTresor)
{
fprintf(fichierTresor, "%s\n", inventaire.tresor[indexTresor].nom);
fprintf(fichierTresor, "%d\n", inventaire.tresor[indexTresor].cout);
}
fprintf(fichierTresor, "%d\n", inventaire.tresorActuel);
fermerFichier(fichierTresor,
"fichier \"armure.txt\", fonction \"sauvegarderTresorInventaire\"");
}
void sauvegarderFormeSalleIndividuelleNiveau(const unsigned int indexSalle)
{
FILE *salle;
char chemin[TAILLE_MAX];
compteur indexLig, indexCol;
sprintf(chemin, "Sauvegarde/%s/Niveau/Salle_%d/salle_%d.txt", personnage.nom, indexSalle + 1, indexSalle + 1);
salle = ouvrirFichier(chemin, "w+",
"fichier \"salle\", fonction \"sauvegarderFormeSalleIndividuelleNiveau\"");
for(indexLig = 0; indexLig < LARGUEUR_SALLE; ++indexLig)
{
for(indexCol = 0; indexCol < LONGUEUR_SALLE; ++indexCol)
fprintf(salle, "%c", niveauActuel.salle[indexSalle].mapSalle[indexLig][indexCol]);
fprintf(salle, "\n");
}
fermerFichier(salle,
"fichier \"salle\", fonction \"sauvegarderFormeSalleIndividuelleNiveau\"");
}
void initialiserTresorInventaire(void)
{
FILE *fichierTresor;
char chemin[TAILLE_MAX];
compteur indexTresor;
sprintf(chemin, "Sauvegarde/%s/Inventaire/tresor.txt", personnage.nom);
fichierTresor = ouvrirFichier(chemin, "w+",
"fichier \"armure.txt\", fonction \"initialiserTresorInventaire\"");
for(indexTresor = 0; indexTresor < NB_TRESOR_MAX; ++indexTresor)
{
fprintf(fichierTresor, "Rien\n");
fprintf(fichierTresor, "0\n");
}
fprintf(fichierTresor, "0\n");
fermerFichier(fichierTresor,
"fichier \"armure.txt\", fonction \"initialiserTresorInventaire\"");
}
int main(int argc, char **argv) {
FILE * f = NULL;
FILE * output = NULL;
Graphe * G = NULL;
char *filename = NULL;
if (argc < 3 || (argc > 1 && (atoi(argv[1]) < 1 || atoi(argv[1]) > 4))) {
fprintf(stdout, "usage: %s <datastruct> <gph-files>\n", argv[0]);
fprintf(stdout, "\n");
fprintf(stdout, "The datastruct parameters are:\n");
fprintf(stdout, " 1 : Ordered linked list\n");
fprintf(stdout, " 2 : Binary heap\n");
fprintf(stdout, " 3 : Packets\n");
fprintf(stdout, " 4 : Packets (circular storage)\n");
return 1;
}
int i;
for (i = 2; i < argc; i++) {
f = ouvrirFichierRead(argv[i]);
G = lectureGraphe(f);
filename = basename(argv[i]);
filename = strtok(filename, ".");
filename = strcat(filename, ".ps");
fprintf(stdout, "Converting %s to %s...\n", argv[i], filename);
Dijkstra * D = NULL;
switch (atoi(argv[1])) {
case 2:
fprintf(stdout, "Using a binary heap\n");
D = dijkstraTas(G, G->s);
break;
case 3:
fprintf(stdout, "Using packets\n");
D = dijkstraPaquet(G, G->s);
break;
case 4:
fprintf(stdout, "Using packets (circular storage)\n");
D = dijkstraPaquetMod(G, G->s);
break;
default:
fprintf(stdout, "Using an ordered linked list\n");
D = dijkstraListe(G, G->s);
break;
}
Arete * sp = extractSP(G, D);
fprintf(stdout, "Cost of the shortest path (Dijsktra) : %d\n",
calculCout(sp));
output = ouvrirFichierWrite(filename);
writeGraphe(output, G);
writeDijkstra(output, G, sp);
fermerFichier(output);
freeArete(sp);
freeDijkstra(D);
fprintf(stdout, "Done.\n");
fprintf(stdout, "\n");
freeGraphe(G);
if (f) {
fermerFichier(f);
}
}
fprintf(stdout, "All tasks completed.\n");
free(filename);
return 0;
}
