Exemple #1
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\"");
}
Exemple #2
0
/**
 * @brief Affiche un puzzle
 * @param[in,out] p le Puzzle à afficher
 * @param[in,out] os le flux de sortie où afficher
 */
void afficher(Puzzle& p, std::ostream& os) {
	os << "*** LEE - long : " << longueur(p.lEE) << endl;
	for (unsigned int i = 0; i < longueur(p.lEE); ++i) {
		afficher(lire(p.lEE, i), os);
		os << endl;
	}
	os << endl << "*** LEAE - long : " << longueur(p.lEAE) << endl;
	for (unsigned int i = 0; i < longueur(p.lEAE); ++i) {
		afficher(lire(p.lEAE, i), os);
		os << endl;
	}
}
Exemple #3
0
/**
 * @brief Cherche l'Etat optimal à traiter dans une liste
 * @param[in,out] l liste des états à explorer
 * @return position de l'Etat optimal à traiter dans l
 */
unsigned int minimal(Liste& l) {
	unsigned int index = 0;
	Etat eMin = lire(l, index);
	for (unsigned int i = 1; i < longueur(l); ++i) {
		Etat e = lire(l, i);
		if (e.g + e.h < eMin.g + eMin.h ||
			(e.g + e.h == eMin.g + eMin.h && e.h <= eMin.h)) {
			eMin = e;
			index = i;
		}
	}
	return index;
}
Exemple #4
0
/**
 * @brief Recherche un Etat dans une liste
 * @param[in] e l'Etat a rechercher
 * @param[in,out] l la Liste dans laquelle chercher
 * @return true si l'Etat a été trouvé, false sinon
 */
bool rechercher(const Etat& e, Liste& l) {
	for (unsigned int i = 0; i< longueur(l); ++i) {
		if (comparer(e.damier, lire(l, i).damier))
			return true;
	}
	return false;
}
/* Charge les tresors de l'inventaire dans le fichier Inventaire/tresor.txt */
void chargerTresorInventaire(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, "r",
	"fichier \"armure.txt\", fonction \"chargerTresorInventaire\"");

	/* On lit les donnees des tresors avec le nom, et le cout (pour les NB_TRESOR_MAX) */

	for(indexTresor = 0; indexTresor < NB_TRESOR_MAX; ++indexTresor)
	{
		lire(fichierTresor, inventaire.tresor[indexTresor].nom);
		fscanf(fichierTresor, "%d\n", &(inventaire.tresor[indexTresor].cout));
	}

	fscanf(fichierTresor, "%d\n", &(inventaire.tresorActuel));

	/* On ferme le fichier Inventaire/tresor.txt */
	fermerFichier(fichierTresor,
	"fichier \"armure.txt\", fonction \"chargerTresorInventaire\"");
}
Exemple #6
0
int main(int argc, char *argv[])
{
	FICHIER *f1;
	FICHIER *f2;
	char c;

	if (argc != 3)
		exit(-1);

	f1 = ouvrir (argv[1], 'L');
	if (f1 == NULL)
		exit (-1);
	
	f2 = ouvrir (argv[2], 'E');
	if (f2 == NULL)
		exit (-1);

	while (lire (&c, 1, 1, f1) == 1) {
		ecrire (&c, 1, 1, f2);
	}

	fermer (f1);
	fermer (f2);

	return 0;
}
void combat_final ()
{
  //Entrée du nom du 1er dresseur
  printf("Dresseur 1, quel est votre nom\n");
  char name_1[20];
  lire (name_1,20);
  Dresseur d1 = name_dresseur (name_1);


  //Ajout des pokemons du dresseur 1
  add_pok (new_pokemon ("Roucarnage", 370, new_attack("Aeropique", 60, 1.0), new_attack("Vol", 90, 0.65), new_attack("Cru-Aile", 60, 1.0), new_attack("Lame d'Air", 75, 0.85)), d1);
  add_pok (new_pokemon ("Salameche", 282, new_attack("Deflagration", 120, 0.45), new_attack("Lance-Flamme", 95, 0.65), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d1);
  add_pok (new_pokemon ("Bulbizarre", 294, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d1);
  add_pok (new_pokemon ("Ronflex", 524, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d1);
  add_pok (new_pokemon ("Krabboss", 314, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d1);
  add_pok (new_pokemon ("Pikachu", 274, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d1);



  //Entrée du nom du deuxième dresseur
  printf("\n\nDresseur 2, quel est votre nom?\n");
  char name_2[20];
  lire (name_2, 20);
  Dresseur d2 = name_dresseur (name_2);

  //Ajout des pokemons du dresseur 2
  add_pok (new_pokemon ("Aquali", 50, new_attack("Tonnerre", 25, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d2);
  add_pok (new_pokemon ("Elektek", 50, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d2);
  add_pok (new_pokemon ("Mackogneur", 50, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d2);
  add_pok (new_pokemon ("Racaillou", 50, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d2);
  add_pok (new_pokemon ("Smogo", 50, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d2);
  add_pok (new_pokemon ("Leviator", 50, new_attack("Tonnerre", 50, 1.0), new_attack("Fatal Foudre", 50, 0.0), new_attack("Charge", 50, 0.6), new_attack("Tacle", 50, 0.6)), d2);

  clear_screen ();
  printf ("Bienvenue a la finale de ce tournoi Pokemon opposant :\n\n" );
  get_dresseur(d1);
  printf("\net\n\n");
  get_dresseur(d2);
  printf("\nQue le combat commence! <Appuyez sur ENTREE pour continuer>\n");
  clear_buffer();
  clear_screen ();
  combat_final_aux (d1, d2);


}
//lecture d'un double
//0 - ERROR
double lireDouble(){
    char nombreTexte[100] = {0};
    if (lire(nombreTexte, 100))    {
        // Si lecture du texte ok, convertir le nombre en long et le retourner
        return strtod(nombreTexte, NULL);
    }else{
        // Si probl�me de lecture, renvoyer 0
        return 0;
    }
}
Exemple #9
0
/*----------------------------------------------------------------------*/
int automate()
{
  char lu; /* caractere lu */
  int e=0; /* etat courant */

  printf("Entrer un mot suivit d'un point (.):\n");

  lu=lire();
 
 while(lu !='.'){
#ifdef TRACE 
  printf("état %d, lettre lue %c, prochaine état %d\n",e,lu,transition[e][code_lettre(lu)]);
#endif
   e=transition[e][code_lettre(lu)];
   if(e==-1) return(ECHEC);
   
   lu=lire();
  }

 return status_etat[e];
}
Exemple #10
0
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\"");
}
Exemple #11
0
/* Cette fonction permet de faire saisir un nombre à l'utilisateur. Il sera récupéré directement en long, et pas en char*. */
long lireLong()
{
    char nombreTexte[100] = {0}; // 100 cases devraient suffire

    if(lire(nombreTexte, 100))
    {
        // Si lecture du texte ok, convertir le nombre en long et le retourner
        return strtol(nombreTexte, NULL, 10);
    }
    else
    {
        // Si problème de lecture, renvoyer -1
        return -1;
    }
}
Exemple #12
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\"");
}
Exemple #13
0
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\"");
}
Exemple #14
0
int main (){
    char commande[MAX_CHAR] = "";
    char hostname[128];
    char last_dir[PATH_MAX] = "";
    char cwd[PATH_MAX + 1]; /*current working directory : tableau pour le chemin*/
    char cwdtmp[PATH_MAX + 1];
    getcwd(cwd, PATH_MAX + 1 );
    getcwd(HISTORY, PATH_MAX);
    strcat(HISTORY, "/history");
    gethostname(hostname, sizeof hostname);

    struct str_commande liste_commande[MAX_COMMANDE];

    do{
        int i;
        for(i=0; i<MAX_COMMANDE; i++){
            memset(liste_commande[i].liste_arg,0,sizeof(char*)*MAX_ARG); /* on met a zero le tableau d'argument*/
            liste_commande[i].nb_arg = 0;
        }

        strcpy(cwdtmp,cwd); /* on copie le curent directory pour pas que strtock le modifie*/
        affiche_directory(last_dir,cwdtmp); /*fonction pour decouper la chaine du PATH*/

        printf("%s@%s:%s ",getlogin(),hostname,last_dir); /* on affiche le login le nom de la machine et le directory*/


        lire(commande, MAX_CHAR);/* lecture de l'entrée utilisateur*/

        gestioncrtl_D(); /* on regarde si on a pas touché sur crtl +D*/

        if(strlen(commande) == 0){ /* on vérifie si l'utilisateur ne rentre pas de commande*/
            printf("Rien écrit\n");
        }
        else{

            enregistreligne(commande); /* enregistre la ligne de commande dans l'HISTORY */

            //fonction_test(liste_arg);
            test_commandes(liste_commande,cwd,commande);

        }
    }while(1);
    return 0;
}
Exemple #15
0
////===========================================================================================
int main() {
    /* installation du handler pour le signal child_signal */
    struct sigaction sig;
    sig.sa_flags = 0;
    sig.sa_handler = child_signal;
    sigemptyset(&sig.sa_mask);
    sigaction(child_signal,&sig,NULL);

    /* désactivation l'interruption par Contrôle+C */
    sig.sa_handler = SIG_IGN;
    sigaction(SIGINT, &sig, NULL);

    initialize_readline ();
    using_history ();

    printf("Lecture de fichier d'histoire : (%s)\n",strerror(read_history (history_filename)));

    while (!Exit) {
        init();
        prompt();
        next=0;
        lire();
        decoupe_ligne_seq();
        int i=0;
        for (;i<numcmd_seq;i++) {
            char *line;
            char* elem[MAXELEMS];
            //strcpy(&line,cmds_seq[i]);
            decoupe_ligne_pipe(cmds_seq[i]);
            if (piped) {
                runPipe();
            } else {
                decoupe_cmd(cmds_seq[i],elem);
                if (redirected) {
                    runRedirectedCommand(elem,red_file,red_type);
                } else {
                    execute(elem);
                }
            }
        }
    }
    printf("Sauvegarde de fichier d'histoire : (%s)\n",strerror(write_history(history_filename)));
    return 0;
}
/* Categorie achat de la boutique */
void acheterBoutique(void)
{
	char commande[TAILLE_MAX];

	effacer();
	titre("Boutique", VERT);

	/* On affiche les explications pour la categorie achat de la boutique */
	lireEtAfficher("Boutique/Texte_Explication_Potion.txt");

	/* On affiche les prix */
	afficherPrixPotionBoutique();

	/* On lit la commande du joueur */
	printf("Que souhaitez-vous faire ? (-1 pour revenir dans la boutique)\n\n");
	printf("> ");
	lire(stdin, commande);

	/* On execute la commande du joueur */
	executerCommandeAcheterBoutique(commande);
}
Exemple #17
0
void chargerTresorInventaire(void)
{
	FILE *fichierTresor;
	char chemin[TAILLE_MAX];
	compteur indexTresor;

	sprintf(chemin, "Sauvegarde/%s/Inventaire/tresor.txt", personnage.nom);

	fichierTresor = ouvrirFichier(chemin, "r",
	"fichier \"armure.txt\", fonction \"chargerTresorInventaire\"");

	for(indexTresor = 0; indexTresor < NB_TRESOR_MAX; ++indexTresor)
	{
		lire(fichierTresor, inventaire.tresor[indexTresor].nom);
		fscanf(fichierTresor, "%d\n", &(inventaire.tresor[indexTresor].cout));
	}

	fscanf(fichierTresor, "%d\n", &(inventaire.tresorActuel));

	fermerFichier(fichierTresor,
	"fichier \"armure.txt\", fonction \"chargerTresorInventaire\"");
}
Exemple #18
0
int partie2 (char* fichier1, char* fichier2){
	FICHIER *f1;
	FICHIER *f2;
	char c;

	f1 = ouvrir (fichier1, 'L');
	if (f1 == NULL)
		exit (-1);
	
	f2 = ouvrir (fichier2, 'E');
	if (f2 == NULL)
		exit (-1);

	while (lire (&c, 1, 1, f1) == 1) {
		ecrire (&c, 1, 1, f2);
	}

	fermer (f1);
	fermer (f2);

	return 0;
}
Exemple #19
0
int main(int argc, char** argv) { char s[512];
    double xmin=-5, xmax=5;
    ARBRE r=NULL;
    int dx=400,dy=200;
    SDL_Surface* f1;

    /* 
       Creation d'une fenetre graphique
       */
    f1=newfenetregraphique(dx,dy);
    Draw_Line(f1,0, 10, 200, 50,0xFFFFFFFF);
    /*
       Lecture d'une expression prefixe au clavier 
       */
    puts("Entrer une expression en notation prefixee"); gets(s);
    r=lire(s);

    /*
       Affichage de cette expression en notation classique
       */
    puts("Expression :"); affiche(r); puts("");


    puts("Entrer les bornes du trace (xmin et xmax): attention au domaine de definition");
    scanf("%lf %lf",&xmin,&xmax);

    /*
       Recherche du min et du max des ordonnees du graphe de la fonction 
       */
    trace1courbe(f1,r,dx,xmin,xmax);
    getchar(); getchar();

    /*
       Liberation de la memoire de l'arbre
       */
    r=libere(r);
    return 0;
}
Exemple #20
0
int get_next_line(int const fd, char **line)
{
	static t_g *s;

	if((fd < 0 || fd > 100) || line == NULL || fd == 42)
		return (-1);
	if(!s)
	{
		s = malloc(sizeof(t_g));
		s->an = NULL;
	}
	line[0] = ft_strnew(1);
	if (s->an)
	{
		if(ft_strchr(s->an, '\n'))
		{
			line[0] = ft_strsub(s->an, 0, bn(s->an));
			s->an  = ft_strchr(s->an, '\n');
			s->an++;
			if (*s->an == '\0')
			{
				s->an = NULL;
				free(s->an);
				return (1);
			}
			else
				return (1);
		}
	}

	line[0] = lire(s, fd, &line[0]);
	if(line[0][0] == '\0' && s->ret == 0)
		return (0);
	else
		return (1);
}
Exemple #21
0
int main(int argc , char **argv)
{
	unsigned int i, taille, op;
	char *data;
	struct stat s;
	FILE * f= NULL;
	unsigned char cle[16];
	unsigned char nonce[16];	
	char fichier[50];
	
	printf("\n");
	//test des arguents et analyse
	if(argc >5 || argc <4)
	{
		printf("-----------Utilisation----------------\n\n");
		printf(" %s F O C [N]\n",argv[0]);
		
		printf("F : le  fichier à chiffrer ou à déchiffrer\n");
		printf("O : l'opération voulue (1 pour chiffrer et 2 pour déchiffrer)\n");
		printf("C : le  fichier contenant la cle de (dé)chiffrement\n");
		printf("N : Dans le cas d'un déchiffrement (2), c'est le  fichier contenant la nonce\n");
		
		printf("\n");
		exit(EXIT_FAILURE);
		
	}
	
	
	
	f = fopen(argv[3],"rb");
	
	if(f == NULL)
		erreur("Ouverture du fichier devant contenir la cle");
	else if(fread(cle,1,16,f)!=16)
		erreur("Lecture dans le fichier contenant la cle de chiffrement / Contenu");
	
	op = atoi(argv[2]);
	
	if(op == 1)//préparation pour le chiffrement
	{
		if(argc != 4)
			erreur("Le nombre d'argument n'est pas compatible avec l'opération demandée");
		
		
		srand(time(NULL));
		for(i=0; i< 16; i++)
			nonce[i] = (unsigned char)rand();
		
		f = fopen("nonce.txt","wb");
		if(f == NULL)
			erreur("Création du fichier qui contiendra la nonce");
		if(fwrite(nonce,1,16,f) != 16)
			erreur("Ecriture dans le fichier qui contiendra la nonce");
		fclose(f);
		
	}
	else if(op == 2)//préparation pour le déchiffrement
	{
		if(argc != 5)
			erreur("Le nombre d'argument n'est pas compatible avec l'opération demandée");
		
		f = fopen(argv[4],"rb");
		if(f == NULL) 
			erreur("Ouverture du fichier  contenant la nonce");
		if(fread(nonce,1,16,f)!=16)
			erreur("Lecture dans le fichier contenant la nonce / Contenu");
		fclose(f);
		
	}
        
        //on récupère des information sur le fichier dont sa taille
	if(stat(argv[1],&s)==-1)
	erreur("Echec: Impossible de déterminer la taille du fichier ");
	
	taille = s.st_size + 10;
	
	if(taille == 1)//fichier vide
		erreur("Echec: Ce fichier est vide\n");
		
	data = malloc(taille*sizeof(char));
	if(data == NULL)
		erreur("Allocation mémoire pour la chaine devant contenir le fichier");
	
	//on récupère le fichier à chiffrer ou déchiffrer, effectue
	// l'opération et le stock dans un fichier dédié
	lire(argv[1],data,taille);
	chiffrement_AES_ModeCompteur(data,taille,nonce, cle);
	if(creation_fichier(argv[1],op,fichier)== 1)
		ecrire(data,taille,argv[1]);
	else
		ecrire(data,taille,fichier);
	
	//succes de l'opération
	if(op == 1)
	{
		printf("fin du chiffrement\n");
		printf("vous trouverez le chiffré dans %s ou dans le source pour le \".png\"\n",fichier);
		printf("vous trouverez la nonce dans le fichier nonce.txt\n");
	}
	else
	{
		printf("fin du déchiffrement\n");
		printf("vous trouverez le déchiffré dans %s ou dans le source pour .png\n",fichier);
	}
	
	printf("\n");
	exit(EXIT_SUCCESS);
}
Exemple #22
0
int main(int argc,char *argv[])
{
	int k,L,H,i,**Pile,**Largeur,**Occ_largeur,*p,*V,opt;
	char a='%',option[3];
	if(argc<2)
	{
		fprintf(stderr,"\nUsage: ./main k [-s]\n");
		return 1;
	}
	else
	{
		
		scanf("%d %d %d",&lc,&hc,&n);
		lire(n);
		k=atoi(argv[1]);
		prof=0;
		Meilleur=malloc(sizeof(struct CONTENEUR));
		Meilleur->contenu=malloc(n*sizeof(LISTE));
		for(i=0;i<n;i++)
		{
			Meilleur->contenu[i]=malloc(sizeof(struct OBJET));
			Meilleur->contenu[i]->nom=malloc(100*sizeof(char));
		}
		Meilleur->Free=malloc(n*sizeof(int));
		Meilleur->num_Bande=malloc(n*sizeof(int));
		Meilleur->rang=malloc(n*sizeof(int));
		Meilleur->coord=malloc(n*sizeof(coordonnee));
		for(i=0;i<n;i++)
			Meilleur->coord[i]=malloc(sizeof(struct COORDONNEE));
		
		Meilleur->surface = 0;
		L=lc;
		H=hc;
		
		LARG=max_dimension();
		Occ_largeur=calloc(n,sizeof(int*));
		for(i=0;i<n;i++)
			Occ_largeur[i]=calloc(k,sizeof(int));
		Largeur=calloc(n,sizeof(int*));
		for(i=0;i<n;i++)
			Largeur[i]=calloc(k,sizeof(int));
		NoFree=calloc(n,sizeof(int));
		num_Bande=calloc(n,sizeof(int));
		rang=calloc(n,sizeof(int));
		
		coord=malloc(n*sizeof(coordonnee));
		for(i=0;i<n;i++)
			coord[i]=malloc(sizeof(struct COORDONNEE));
		
		/* tableaux pour le sac à dos */
		p=malloc( (n+2)*(sizeof(int)) );
		V=malloc( (n+2)*(sizeof(int)) );
		Matrice_Sac=malloc( (n+1)*(sizeof(int*)) ) ;
		for(i=0;i<n+1;i++)
			Matrice_Sac[i]=malloc( (hc+1)*(sizeof(int)) );
		if(argc==3)
		{
			strcpy (option, argv[2]);
			if(strcmp (option,"-s")==0)
			{
				opt=1;
			}
		}
		else opt=0;
		if(opt==1)
		{
			fprintf(stdout,"\n*****REMPLISSAGE PAR L'ALGORITHME DE SAC A DOS******\n");
			remplir_conteneur(L,H,k,Largeur,Occ_largeur,p,V,0);
		}
		else
		{
			fprintf(stdout,"\n*****REMPLISSAGE PAR LA METHODE GLOUTON******\n");
			remplir_conteneur(L,H,k,Largeur,Occ_largeur,p,V,1);
		}
			
		Pile=malloc(n*sizeof(int *));
		for(i=0;i<n;i++)
			Pile[i]=malloc(sizeof(int));
		Pile=Sauvegarde(Meilleur->Free,Meilleur->num_Bande,Meilleur->rang);
		printf("\n");
		affichageSolution(Pile,Meilleur->contenu,Meilleur->Free,Meilleur->num_Bande,Meilleur->rang,Meilleur->coord);
		
		printf("\n remplissage à :%.2f%c\n",(double)100*Meilleur->surface/(hc*lc),a);
		
	}
	return 0;
}
Exemple #23
0
/**
 * @brief Résout un puzzle
 * @param[in,out] p le puzzle à résoudre
 * @param[in] t le damier initial
 * @param[in,out] os flux de sortie
 */
void jouer(Puzzle& p, const Tab2D& t, std::ostream& os) {
	Etat etatInitial;
	Etat etatCourant;
	Tab2D damierFinal;
	Etat etatDerive;

	double tempsDebutRecherche = getTime();

	but(damierFinal, t.nbL, t.nbC);
	initialiser(etatInitial.damier, t.nbL, t.nbC);
	etatInitial.mouvement = FIXE;
	etatInitial.precedent = 0;
	etatInitial.g = 0;

	//Copie du damier inititial dans etatInitial
	for (unsigned int l = 0; l < t.nbL; ++l) {
		for (unsigned int c = 0; c < t.nbC; ++c) {
			etatInitial.damier.tab[l][c] = t.tab[l][c];
		}
	}
	etatInitial.h = manhattan(etatInitial.damier, damierFinal);

	initialiser(etatDerive.damier, t.nbL, t.nbC);

	inserer(p.lEAE, 0, etatInitial); //étatInitial dans LEAE

	bool solutionTrouvee = false;
	bool mvtPossible;
	unsigned int pos;

	while (p.lEAE.nb != 0) {
		pos = minimal(p.lEAE);
		etatCourant = lire(p.lEAE, pos); //on prend le 1er état à explorer
		//insérer étatCourant dans LEE
		inserer(p.lEE, longueur(p.lEE), etatCourant);
		supprimer(p.lEAE, pos); //supprimer étatCourant de LEAE

		if (etatCourant.h == 0) { // le damier de étatCourant est le damier but
			solutionTrouvee = true;
			break; //sortir de la boucle while
		}

		/*pour_tout (mouvement possible associé à étatCourant)
		mouvement possible relatif à damier de étatCourant (etatCourant.damier)
		ordre d'exploration (obligatoire) NORD, EST, SUD, OUEST */
		//initialiser un étatDérivé // d'après le mouvement

		for(int m = OUEST; m >= NORD; --m) {
			mvtPossible = deriver(etatCourant, (Mouvement) m, etatDerive);
			if (mvtPossible && !rechercher(etatDerive, p.lEAE)\
				&& !rechercher(etatDerive, p.lEE)) {
				etatDerive.precedent = longueur(p.lEE) - 1;
				etatDerive.h = manhattan(etatDerive.damier, damierFinal);
				etatDerive.g = etatCourant.g + 1;
				//insérer étatDérivé dans LEAE
				inserer(p.lEAE, longueur(p.lEAE), etatDerive);
			}
		}
	}

	double tempsFinRecherche = getTime();
	cout << "Durée de recherche : " << tempsFinRecherche - tempsDebutRecherche
		<<" seconde(s)."<< endl;

	if (solutionTrouvee) {
		Pile sol;
		Etat etatSol;
		initialiser(sol, 3, 2);
		initialiser(etatSol.damier, t.nbL, t.nbC);

		//Stockage de la solution
		etatSol = lire(p.lEE, longueur(p.lEE)-1);
		empiler(sol, etatSol);
		while (etatSol.precedent != 0) {
			etatSol = lire(p.lEE, etatSol.precedent);
			empiler(sol, etatSol);
		}
		empiler(sol, etatInitial);

		//Affichage de la solution
		os << "Damier : " << t.nbL << " lignes " << t.nbC << " colonnes"
			<< endl;
		os << "Solution en " << sol.sommet << " mouvements" << endl;
		while (!estVide(sol)) {
			afficher(sommet(sol), os);
			os << endl;
			depiler(sol);
		}
		detruire(sol);
		detruire(etatSol.damier);
	}
	else {
		os << "Solution non trouvée" << endl;
	}
	detruire(etatInitial.damier);
	detruire(etatCourant.damier);
	detruire(etatDerive.damier);
	detruire(damierFinal);
}