Shader::Shader(Shader const &shader) : m_vertexSource(shader.m_vertexSource), m_fragmentSource(shader.m_fragmentSource), m_vertexID(0), m_fragmentID(0), m_programID(0), m_initialise(shader.m_initialise)
{
// On initialise le shader si le shader source est lui aussi initialisé
if(m_initialise == true)
initialiser();
}
int main (int argc, char *argv[ ])
{
unsigned int frameLimit = SDL_GetTicks() + DELAI_ENTRE_IMAGES;
int go = 1;
initialiser(&donnees);
atexit(nettoyer);
// Boucle infinie, principale, du jeu
while (go == 1)
{
// Entrées clavier
recupEvenement(&donnees);
// Affichage
rendu(&donnees);
delay(frameLimit);
frameLimit = SDL_GetTicks() + DELAI_ENTRE_IMAGES;
}
// Fin
exit(0);
}
Shader& Shader::operator=(Shader const &shader)
{
// Si le shader à copier n'est pas lui-même
if(this != &shader)
{
// Copie des sources
m_vertexSource = shader.m_vertexSource;
m_fragmentSource = shader.m_fragmentSource;
m_initialise = shader.m_initialise;
// Destruction du shader actuel
detruire();
// Initialisation du nouveau shader
initialiser();
}
return *this;
}
File< Objet >::File ( unsigned int capacite, unsigned int increment )
/*------------------------------------------------------------------------- */
{
this->capacite = capacite;
this->increment = increment;
initialiser ( ) ;
}
void diffuser( double cyl[], int nbp, int nbit, double gauche, double droite )
{
// On cree un tableau auxiliaire pour representer le cylindre au
// temps suivant, d'ou le "p1" (plus 1).
double *cylp1 = malloc( sizeof(double) * nbp );
initialiser( cylp1, nbp, gauche, droite );
// On repete pendant le nombre d'iterations desirees.
for ( int k = 0; k < nbit; k++ ) {
// On calcule la prochaine approximation (temporelle).
cylp1[0] = cyl[0];
for ( int i = 1; i < nbp-1; i++ ) {
cylp1[i] = 0.5 * (cyl[i-1] + cyl[i+1]);
}
cylp1[nbp-1] = cyl[nbp-1];
// On interchange le role des deux tableaux.
double *temp = cylp1; cylp1 = cyl; cyl = temp;
// De temps en temps, on imprime.
if ( k > 0 && nbIterationsImpression != 0 && k % nbIterationsImpression == 0 ) {
imprimer( cyl, nbp, k );
}
}
}
int main(int argc, char **argv)
{
initialiser(&argc, &argv);
Widget *fen = fenetre_creer("Ma fenetre", .estPrincipale = TRUE);
Widget *hbox = conteneur_h_creer();
Widget *vbox = conteneur_v_creer();
conteneur_ajouter(fen, hbox);
conteneur_ajouter(hbox, vbox);
Widget *bouton1 = bouton_creer("bouton1");
Widget *bouton2 = bouton_creer("bouton2");
Widget *bouton3 = bouton_creer("bouton3");
Widget *checkbox = checkbox_creer("Case à cocher!!");
Widget *menu = menu_creer(3, "Element 1", "Element 2", "Element 3");
conteneur_ajouter(vbox, bouton1);
conteneur_ajouter(vbox, bouton2);
conteneur_ajouter(vbox, checkbox);
conteneur_ajouter(hbox, bouton3);
conteneur_ajouter(hbox, menu);
fenetre_afficher(fen);
boucle_principale();
return 0;
}
File< Objet >::File ( void )
/*------------------------------------------------------------------------- */
{
capacite = capaciteImplicite;
increment = incrementImplicite;
initialiser ( ) ;
}
int main(int argc, char * argv[])
{
/*declaration des variables*/
int i;
int ** grille = (int**)malloc(N*sizeof(int *));
/*int ** reservation = (int**)malloc(N*sizeof(int *));*/
int * remplissage = (int*)malloc(sizeof(int));
int temp;
int res = 0;
/* fin des declarations*/
*remplissage = 0;
for(i=0;i<N;i++)
grille[i]=(int *)malloc(N*sizeof(int));
printf("*****SUDOKU*****\n");
temp = initialiser(grille);
/*temp = initialiser(reservation);*/
generer(grille,remplissage);
printf("remp=%d\n",*remplissage);
afficher(grille);
while(res==0)
{
saisir(grille,remplissage);
afficher(grille);
printf("remp=%d\n",*remplissage);
if(*remplissage == 81)
res=verif_grille(grille);
}
printf("Bravo,reussi\n");
return 0;
}
int main()
{
initialiser();
ajusterPWM(150, 0);
_delay_ms(1500);
ajusterPWM(0, 0);
}
Guideline::Guideline(dirctn t, double position)
: Indicator(ZORD_Guideline)
{
type = t;
setItemType(x_guideline);
initialiser(position);
}
Guideline::Guideline(Canvas *canvas, const QDomElement& node, const QString& ns):
Indicator(node, ns, ZORD_Guideline)
{
Q_UNUSED (canvas)
type = (dirctn) essentialProp<int>(node, x_direction, ns);
double position = essentialProp<double>(node, x_position, ns);
initialiser(position);
}
int main( int argc, char *argv[] )
{
// On obtient et on valide les arguments du programme.
if ( argc < 6 ) {
printf( "usage:\n" );
printf( " %s nbp nbit gauche droite nbThreads\n", argv[0] );
printf( " nbp : Nombre de points a utiliser\n" );
printf( " nbit : Nombre d'iterations a simuler\n" );
printf( " gauche : Temperature extremite gauche\n" );
printf( " droite : Temperature extremite droite\n" );
printf( " nbThreads : Nombre de threads a utiliser\n" );
printf( "" );
printf( "Il faut aussi definir NB_ITERATIONS_IMPRESSION!\n" );
return(-1);
}
int nbp = atoi( argv[1] );
assert( nbp > 0 );
int nbit = atoi( argv[2] );
assert( nbit > 0 );
double gauche = atof( argv[3] );
double droite = atof( argv[4] );
// On fixe le nombre de threads a utiliser.
int nb_threads = atoi( argv[5] );
assert( nb_threads > 0 );
omp_set_dynamic(0);
omp_set_num_threads(nb_threads);
// On alloue l'espace pour le tableau de valeurs representant le
// cylindre et on les initialise.
double *cyl = malloc( sizeof(double) * nbp );
initialiser( cyl, nbp, gauche, droite );
// On indique si, de temps en temps, il faut imprimer pour voir l'evolution.
char *s = getenv("NB_ITERATIONS_IMPRESSION");
if ( s != NULL && strcmp(s, "") != 0 ) {
nbIterationsImpression = atoi(s);
}
// On diffuse pendant le nombre d'iterations requis.
diffuser( cyl, nbp, nbit, gauche, droite );
// On emet le resultat sur stdout, si demande.
if ( nbIterationsImpression != 0 ) {
imprimer( cyl, nbp, nbit );
}
return( 0 );
}
/**
* @brief Définit le damier but du Puzzle
* @param[out] t Tab2D dans lequel stocker le but
* @param[in] nbl le nombre de lignes
* @param[in] nbc le nombre de colonnes
*/
void but(Tab2D& t, const unsigned int nbl, const unsigned int nbc) {
initialiser(t, nbl, nbc);
char lettre = 'A';
for (unsigned int l = 0; l < nbl; ++l) {
for(unsigned int c = 0; c < nbc; ++c) {
t.tab[l][c] = lettre;
++lettre;
}
}
t.tab[nbl-1][nbc-1] = '#';
}
int main (int argc, char *argv[])
{
/** VARIABLES LOCALES */
int grille[N][N][2];
int remplissage=0, verif=1,i,j,n=N*N,g;
/** Affichage & Initialisation */
printf("SODOKU\n");
initialiser(grille);
/** Generer grille aléatoire */
printf("germe ? ");
fflush(stdout);
scanf("%d%*c",&g);
remplissage = generer(grille,g);
affiche(grille);
/*Test de grille_test*/
/*for(i=0;i<N;i++)
{
for(j=0;j<N;j++)
{
grille[i][j][0] = grille_test[i][j];
}
}
printf("germe ? ");
fflush(stdout);
scanf("%d%*c",&g);
remplissage = n - generer2(grille,g);
affiche(grille);*/
printf("Nombre de chiffre place = %d\n",remplissage);
/** boucle du jeu */
do
{
remplissage = saisir(grille,remplissage);
affiche(grille);
printf("Nombre de chiffre place = %d\n",remplissage);
if ((remplissage >= n) && (verifierGrille(grille) != 1))
{
verif=0;
}
} while (verif!=0);
printf("GAGNE !\n");
return 0;
}
int main()
{
srand(time(NULL));
liste l = initialiser();
//vide(l);
//afficher_liste(l);
l = ajoutdebut(l,10);
l = ajoutfin(l,15);
l = ajouttrie(l,13);
afficher_liste(l);
testajout();
return 0;
}
int main(void)
{
File *myFile = initialiser();
remplirFile(myFile, 4);
remplirFile(myFile, 8);
remplirFile(myFile, 15);
remplirFile(myFile, 16);
remplirFile(myFile, 32);
remplirFile(myFile, 42);
afficherFile(myFile);
defiler(myFile);
defiler(myFile);
afficherFile(myFile);
return 0;
}
void testajout()
{
int a;
liste l1 = initialiser();
/*liste l2 = initialiser();
liste l3 = initialiser();*/
do
{
a = alea(10);
l1 = ajoutdebut(l1,a);
/*l2 = ajoutfin(l2,a);
l3 = ajouttrie(l3,a);*/
} while (a != 0);
afficher_liste(l1);
//afficher_liste(l2);
//afficher_liste(l3);
}
int main (int argc, char *argv[])
{
struct Matrice m;
struct Matrice I;
int i;
initialiser(&m);
m.contenu[3][1] = 9.0;
m.contenu[7][19] = 3.0;
afficher(&m);
// Creer la matrice Identite
for (i = 0; i < 20; i++) {
I.contenu[i][i] = 1.0;
}
multiplier(&m, &I, &m);
afficher(&m);
return 0;
}
/* Remplir un tas à partir d'un réseau avec tous les noeux ayant une distance max */
Tas *initTas(Reseau *res)
{
Tas *tas;
CellNoeud *n = NULL;
Elem *el;
//creer un tas de la taille du reseau
tas = initialiser(res->nbNoeuds);
//inserer tous les noeuds du reseau avec une distance max
n = res->noeuds;
while(n != NULL) {
el = creerElem();
remplirElem(el, n->cour, -1, FLT_MAX);
ajouter(tas, el, FLT_MAX);
n = n->suiv;
}
return tas;
}
int main()
{
noeud *root;
root = initialiser();
add_word(root,"magneti");
add_word(root,"magneton");
add_word(root,"smogo");
add_word(root,"smogogo");
add_word(root,"nidoran");
add_word(root,"nidorina");
add_word(root,"nidoqueen");
add_word(root,"nidoking");
aff_noeud(root);
suppr_word(root,"trololo");
suppr_word(root,"nidorina");
suppr_word(root,"magneti");
aff_noeud(root);
return (EXIT_SUCCESS);
}
int main(int argc, char** argv){
time_t t;
srand((unsigned)time(&t));
pthread_t chevaliers_t[11];
pthread_t pecore_t[7];
pthread_t arthur_t;
char* nomsChevalier[] = {"Bohort", "Calogrenant", "Karadoc", "Dagonet", "Galessin", "Gauvain", "Hervé de Rinel", "Lancelot", "Léodagan", "Perceval", "Yvain"};
char* nomsPecores[] = {"Guethenoc", "Roparzh", "Pecore En plus 1", "Pecore En plus 2", "Pecore En plus 3", "Pecore En plus 4", "Pecore En plus 5"};
sem_init(&chevalierDispo, 0, 11);
sem_init(&readyForGraal, 0, 1);
sem_init(&justiceRendue, 0, 1);
attenteJugement = initialiser();
for(int i=0; i<11; i++){
pthread_create(&chevaliers_t[i], NULL, chevalier, (void*)nomsChevalier[i]);
}
for(int i = 0; i<6; i++){
pthread_create(&pecore_t[i], NULL, pecore, (void*)nomsPecores[i]);
}
pthread_create(&arthur_t, NULL, arthur, NULL);
pthread_join(arthur_t, NULL);
for(int i=0; i<11; i++){
pthread_join(chevaliers_t[i], NULL);
}
for(int i = 0; i<6; i++){
pthread_join(pecore_t[i], NULL);
}
sem_destroy(&chevalierDispo);
sem_destroy(&readyForGraal);
sem_destroy(&justiceRendue);
return 0;
}
int MSudoku::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: generer(); break;
case 1: initialiser(); break;
case 2: sauvegarder(); break;
case 3: charger(); break;
case 4: changerTheme(); break;
case 5: apropos(); break;
case 6: resoudre(); break;
case 7: verification(); break;
case 8: possibilites(); break;
case 9: gagner(); break;
}
_id -= 10;
}
return _id;
}
//Programme principal
int main()
{
int i;
int **matrice;
matrice = malloc(TAILLE*sizeof(int*));
for (i = 0; i < TAILLE; ++i)
matrice[i] = malloc (sizeof(int)*TAILLE);
//Il faudrait vérifier si l'allocation dynamique s'est bien déroulée
srand (time(NULL));
printf("Bienvenue dans le Jeu De La Vie ! Appuyez sur 'Entrer' pour commencer...\n");
getchar();
initialiser(matrice);
printf("La population au départ : \n");
afficher(matrice);
printf("\nPressez sur ENTER pour continuer...\n");
getchar();
for(i=0; i<CYCLE; i++)
{
modifierMatrice(matrice);
printf("La population après %d cycles: \n",i+1);
afficher(matrice);
printf("Pressez sur ENTER pour continuer...\n");
getchar();
}
printf("Nombre de cycle terminé\n");
return 0;
}
int main( int argc, char *argv[] )
{
// créer une fenêtre
FenetreTP fenetre( "INF2705 TP" );
// allouer des ressources et définir le contexte OpenGL
initialiser();
bool boucler = true;
while ( boucler )
{
// affichage
fenetre.afficherScene();
fenetre.swap();
// récupérer les événements et appeler la fonction de rappel
boucler = fenetre.gererEvenement();
}
// détruire les ressources OpenGL allouées
conclure();
return 0;
}
int main ()
{
char choix;
printf("Voulez-vous jouer contre l'ordinateur ? (O/n)\n");
scanf("%c",&choix);
if (choix == 'O' || choix == 'o')
contre_ia = 1;
printf("[SYS] Entrez le nom du joueur1 (X) : ");
scanf("%s",joueur1);
if (contre_ia) {
strcpy(joueur2,"PC");
} else {
printf("[SYS] Entrez le nom du joueur2 (O) : ");
scanf("%s",joueur2);
}
printf("[SYS] Joueur1(X): \"%s\", Joueur2(O): \"%s\"\n",joueur1, joueur2);
initialiser();
afficher_plateau();
int finished=0;
while(!finished)
{
int val = recuperer_valeur();
if (val < 0)
finished=1;
/* Dans la table ASCII: • les minuscules sont entre 97 et 122
• Les majuscules entre 65 et 90;
*/
int x,y;
y = (jeu[1] - '0') -1;
if (jeu[0] >= 65 && jeu[0] < 73) /* 73 pour s'arrêter à H */
x = jeu[0] - 65;
else if (jeu[0] >= 97 && jeu[0] < 105) /* 105 pour s'arrêter à h */
x = jeu[0] - 97;
else {
fprintf(stderr, "[ERR] Vous avez entré une valeur erronnée.\n");
continue;
}
if (strcmp(jeu,"tab") == 0)
continue;
if ((x < 0 || x > 8 || y < 0 || y > 8))
{
fprintf(stderr, "[ERR] Vous avez entré une valeur erronnée.\n");
continue;
}
if (plateau[x][y] != 0) {
fprintf(stderr, "[ERR] La case est déjà remplie :( Réessayez\n");
continue;
}
if (!test_adjacence(x,y) || !test_coup(x,y)) {
fprintf(stderr, "[ERR] Ce coup est impossible. Réessayez\n");
continue;
}
jouer_coup(x,y);
turn = (turn == 1) ? 2 : 1;
afficher_plateau();
}
printf("Terminé ! %s a eu %d, %s a eu %d\n",joueur1, score_j1, joueur2, score_j2);
return 0;
}
int main()
{
initialiser();
del led(0);
midi piezzo(&PORTB, &DDRB, 2, 0);
Memoire24CXXX mem; // objet mémoire
uint8_t lu = 0, pointLecture = 0; // variables de lecture
uint8_t compteur = 0, temp = 0; // variable boucle
bool verifBoucle = false;
led.clignoter(10,10);
while(lu != 0x01) //dbt
{
mem.lecture(pointLecture,&lu);
pointLecture ++ ;
}
pointLecture++;
mem.lecture(pointLecture, &lu);
pointLecture++;
while(lu != 0xFF) //fin
{
switch(lu)
{
case 0x02 : //att
mem.lecture(pointLecture, &lu);
delais(25*(uint16_t)lu);
pointLecture++;
break ;
case 0x44 : //dal
mem.lecture(pointLecture, &lu);
led.allumer(1);
pointLecture++;
break;
case 0x45 : //det
mem.lecture(pointLecture, &lu);
led.eteindre();
pointLecture++;
break;
case 0x48 : //sgo
mem.lecture(pointLecture, &lu);
piezzo.jouerNote(lu-40);
pointLecture ++;
break;
case 0x09 : //sar
piezzo.arreterNote();
pointLecture++;
break;
case 0x62 : // mav
mem.lecture(pointLecture, &lu);
PORTD |= 0x0C; //0000 1100
ajusterPWM(lu<<1, lu<<1);
pointLecture++;
break;
case 0x60 : //mar1
case 0x61 : //mar2
ajusterPWM(0, 0);
delais(400);
pointLecture++;
break;
case 0x63 : //mre
mem.lecture(pointLecture, &lu);
PORTD &= (unsigned char) ~(3<<(2));
ajusterPWM(lu<<1, lu<<1);
pointLecture++;
break;
case 0x64 : //trd
ajusterPWM(200, 0);
_delay_ms(985);
ajusterPWM(0, 0);
delais(400);
pointLecture++;
break;
case 0x65 : //trg
ajusterPWM(0, 200);
_delay_ms(831);
ajusterPWM(0, 0);
delais(400);
pointLecture++;
break;
case 0xC0 : //dbc
mem.lecture(pointLecture, &lu);
pointLecture++;
compteur = lu + 1;
temp = pointLecture;
verifBoucle = true;
case 0xC1 : //fbc
if(verifBoucle && compteur)
{
compteur-- ;
pointLecture = temp;
}
else
{
pointLecture++;
verifBoucle = false;
}
break;
}
mem.lecture(pointLecture, &lu);
pointLecture ++;
}
return 0;
}
int main(int argc, char ** argv )
{ mesJoueurs=initialiser();
int port=2013;
int i=0;
int sock_server,sock_client,c,*nouveauSocket,*spectateur;
int on=1;
struct sockaddr_in server,client;
/*recuperer les arguments qui existent pour initialiser le timeout port et max*/
for(i=0;i<argc;i++)
{
if(strcmp(argv[i],"-timeout")==0)
{
printf(" %s detecté \n",argv[i]);
timeout=atoi(argv[i+1]);
}
if(strcmp(argv[i],"-max")==0)
{
printf(" %s detecté \n",argv[i]);
MaxJoueur=atoi(argv[i+1]);
}
if(strcmp(argv[i],"-port")==0)
{
printf(" %s detecté \n",argv[i]);
port=atoi(argv[i+1]);
}
if(strcmp(argv[i],"-dico")==0)
{
printf("%s detecté \n",argv[i]);
fichier=argv[i+1];
if((monFichier=fopen(fichier,"r"))==NULL)
{
perror("<<fichier>>");exit(EXIT_FAILURE);
}
}
}
if(monFichier==NULL)
{
printf("vous devez specifier le dictionnaire de mot -dico \n");
exit(EXIT_FAILURE);
}
if((maBase=fopen("database.txt","a+"))==NULL)
{
perror("erreur creation de la database");
}
pthread_t monThread[MaxJoueur];
Joueur joueurs[MaxJoueur];
printf("timeout vaut %d MaxJoueur vaut %d et le port vaut %d \n",timeout,MaxJoueur,port);
/*creaction de la socket de connection et attendre nbMax de connection */
if((sock_server=socket(AF_INET,SOCK_STREAM,0))<0)
{
perror("erreur <<socket>>");
exit(EXIT_FAILURE);
}
/*parametrage du port du serveur et de l'IP */
printf("Socket creer avec succée \n");
server.sin_family=AF_INET;
server.sin_addr.s_addr=INADDR_ANY;
server.sin_port=htons(port);
/*parametre pour pouvoir reutiliser le port */
setsockopt(sock_server,SOL_SOCKET,SO_REUSEADDR,(void*)&on,sizeof(on));
/*on bind la socket */
if(bind(sock_server,(struct sockaddr *)&server,sizeof(server))<0)
{
perror("bind <<socket_server>>");
exit(EXIT_FAILURE);
}
printf("bind reussi \n");
listen(sock_server,MaxJoueur);
/*accepter la connexion des max des joueurs */
c=sizeof(struct sockaddr_in);
nouveauSocket=malloc(MaxJoueur);
for(i=0;i<MaxJoueur;i++)
{
nouveauSocket[i]=accept(sock_server,(struct sockaddr *)&client,(socklen_t *)&c);
if(pthread_create(&monThread[i],NULL,handlerConnexion,(void *)&nouveauSocket[i])<0)
{
perror("pthread_create <<monThread>>");
exit(EXIT_FAILURE);
}
}
pthread_cond_wait(¬ifierJoueurs,&mutex);
setDessinateur(mesJoueurs);
/* dessinateur=getDessinateur(mesJoueurs); */
if(fgets(buffer,TAILLE_BUFFER,monFichier)!=NULL)
{
int n=strlen(buffer);
buffer[n-1]='\0';
aDessiner=buffer;
printf(" le mot a dessiner est %s lol ",aDessiner);
sleep(1);
EnvoyerRole(mesJoueurs,buffer);
}
spectateur=malloc(12);
while((spectateur[i]=accept(sock_server,(struct sockaddr *)&client,(socklen_t *)&c)))
{
pthread_t spectateur_thread;
if(pthread_create(&spectateur_thread,NULL,handlerConnexion,(void *)&spectateur[i])<0)
{
perror("erreur dans thread spectateur");exit(EXIT_FAILURE);
}
i++;
}
for(i=0;i<MaxJoueur;i++)
{
pthread_join(monThread[i],NULL);
}
return EXIT_SUCCESS;
}
int main(int argc, char** argv)
{
/*variables locales*/
login_t * ptete;
login_t * ajout;
int confirm = 1;
char demande_ajout_t;
char demande_position_t;
/*allocation du pointeur vers le premier élement de la structure*/
ptete = (login_t *) malloc (sizeof(login_t));
(*ptete).suivant = NULL;
/*initialisation des éléments*/
initialiser(ptete);
while (confirm == 1)
{
/*demande/choix entre la modif ou la création d'un compte*/
printf("Voulez-vous ajouter, supprimer un compte ou ne rien faire ? (a/s/f) ");
fflush(stdout);
scanf("%s%*c",&demande_ajout_t);
if ((demande_ajout_t == 'a') && (strcmp("vide", (*ptete).nom_de_login) == 0))
{
/*ajout d'un compte sur un élément vide*/
saisie(ptete);
}
else if (demande_ajout_t == 'a')
{
/*ajout d'un compte par création d'un élément*/
ajout = (login_t *) malloc(sizeof(login_t));
if (ajout == NULL)
{
printf("Erreur d'allocation");
}
else
{
/*saisie du compte*/
saisie(ajout);
/*ajout du compte au gestionnaire*/
printf("Voulez-vous ajouter le compte en fin, au milieu ou au debut (f/n/d) ? ");
fflush(stdout);
scanf("%c%*c", &demande_position_t);
if (demande_position_t == 'f')
{
inserFin(ptete,&ajout);
}
else if (demande_position_t == 'd')
{
inserTete(&ptete,&ajout);
}
else if (demande_position_t == 'm')
{
inserMilieu(ptete,&ajout);
}
}
}
else if (demande_ajout_t == 's')
{
supprimer(&ptete);
}
else
{
confirm = 0;
}
}
/*affichage des élements*/
affichage(ptete);
/*libération de la mémoire allouée*/
liberation(&ptete);
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);
}
/**
* @brief Initialise un puzzle
* @param[out] p le puzzle à initialiser
*/
void initialiser(Puzzle& p) {
initialiser(p.lEE);
initialiser(p.lEAE);
}
