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\"");
}
/**
* @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;
}
}
/**
* @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;
}
/**
* @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\"");
}
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;
}
}
/*----------------------------------------------------------------------*/
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];
}
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\"");
}
/* 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;
}
}
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\"");
}
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;
}
////===========================================================================================
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);
}
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\"");
}
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;
}
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;
}
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);
}
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);
}
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;
}
/**
* @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);
}
