NodePtr saisie_expression()
{
Pile* stack = creer_pile();
char c = '\0';
NodePtr tmp;
while (c != '\n')
{
c = getchar();
switch (c)
{
case '+':
case '*':
tmp = creer_noeud(c, '\0');
tmp->right = depiler(stack);
tmp->left = depiler(stack);
empiler(stack, tmp);
break;
default:
if (c >= '0' && c <= '9') // Si le caract�re saisi est un chiffre
empiler(stack, creer_noeud('\0', c - '0')); // On l'empile on le convertissant en entier
else if (c >= 'a' && c <= 'z') // Le caract�re est une variable
empiler(stack, creer_noeud(c, '\0'));
else if (c != '\n' && c != ' ')
printf("Erreur de saisie.\n");
break;
}
}
return depiler(stack);
}
/*@requires: p non NULL, p initalisée
@assigns: p
@ensures: on a empilé la valeur du sommet actuel diminué de 1,
retourne 1 si l'opération est réussie, 0 sinon*/
void empiler_moins_un(pile *p) {
if(est_pleine(*p))
return 0;
int sommet = depiler(p);
empiler(p, sommet);
empiler(p, sommet - 1);
return 1;
}
/*@requires: p non NULL, p initalisée
@assigns: p
@ensures: duplique l'élément au sommet de la pile,
retourne 1 si l'opération est réussie, 0 sinon*/
void dupliquer_sommet(pile *p) {
if(est_pleine(*p))
return 0;
int sommet = depiler(p);
empiler(p, sommet);
empiler(p, sommet);
return 1;
}
/*@requires: p non NULL, p initalisée
@assigns: p
@ensures: on empile le sommet moins un puis le produit des deux derniers
éléments (en ayant préalablement dépilé ces deux éléments),
retourne 1 si l'opération est réussie, 0 sinon*/
void empiler_produit_deuxpremierselements(pile *p) {
if(est_vide(*p))
return 0;
int n, m;
n = depiler(p);
m = depiler(p);
empiler(p, n*m);
empiler(p, n-1);
return 1;
}
/*@requires: n >= 0
@assigns: rien
@ensures: renvoie la factorielle de n*/
int factorielle2(int n) {
if(n <= 0)
return 1;
pile p = creer_vide();
empiler(&p, n);
empiler(&p, n-1);
for(n = n-1; n > 0; n--)
empiler_produit_deuxpremierselements(&p);
depiler(&p);
return depiler(&p);
}
/*fonction chemin
*param:structure matrice, la lettre à tester, le rand k correspondant à la Keme lettre du mot, structure redondance
*verification (dans les 8 directions) si autour d'une lettre à tester se trouve la lettre au rang k+1 du mot a tester
*si oui: on empile les coordonnées, on change de rang k et on continue a chercher la lettre suivante
*sinon: on depile le chemin precedemment empile
*condition de chaque if:ligne et colonne present dans la matrice / si la lettre recherchee est presente / si nous ne sommes pas déjà passé par la case(ligne,colonne)
*/
void chemin(t_case matrice[TAILLE_MATRICE][TAILLE_MATRICE],char lettre,int *k,t_coord redondance[TAILLE_MATRICE*TAILLE_MATRICE]){
//declaration
int ligne=sommetpile_ligne();
int colonne=sommetpile_colonne();
//traitement
//case ligne-1,colonne-1
if(ligne-1>=0 && colonne-1>=0 && matrice[ligne-1][colonne-1].lettre== lettre && !recherche_redondance(redondance,ligne-1,colonne-1)){
empiler(ligne-1,colonne-1);
ajouter_coordonnee(redondance,ligne-1,colonne-1);
*k=*k+1;
}
//case ligne-1,colonne
else if(0<=ligne-1 && matrice[ligne-1][colonne].lettre== lettre && !recherche_redondance(redondance,ligne-1,colonne)){
empiler(ligne-1,colonne);
ajouter_coordonnee(redondance,ligne-1,colonne);
*k=*k+1;
}
//case ligne-1,colonne+1
else if(0<=ligne-1 && colonne+1<TAILLE_MATRICE && matrice[ligne-1][colonne+1].lettre== lettre && !recherche_redondance(redondance,ligne-1,colonne+1)){
empiler(ligne-1,colonne+1);
ajouter_coordonnee(redondance,ligne-1,colonne+1);
*k=*k+1;
}
//case ligne,colonne+1
else if(colonne+1<TAILLE_MATRICE && matrice[ligne][colonne+1].lettre==lettre &&!recherche_redondance(redondance,ligne,colonne+1)){
empiler(ligne,colonne+1);
ajouter_coordonnee(redondance,ligne,colonne+1);
*k=*k+1;
}
//case ligne+1,colonne+1
else if(ligne+1<TAILLE_MATRICE && colonne+1<TAILLE_MATRICE && matrice[ligne+1][colonne+1].lettre== lettre && !recherche_redondance(redondance,ligne+1,colonne+1)){
empiler(ligne+1,colonne+1);
ajouter_coordonnee(redondance,ligne+1,colonne+1);
*k=*k+1;
}
//case ligne+1,colonne
else if(ligne+1<TAILLE_MATRICE && matrice[ligne+1][colonne].lettre== lettre && !recherche_redondance(redondance,ligne+1,colonne)){
empiler(ligne+1,colonne);
ajouter_coordonnee(redondance,ligne+1,colonne);
*k=*k+1;
}
//case ligne+1,colonne-1
else if(ligne+1<TAILLE_MATRICE && 0<=colonne-1 && matrice[ligne+1][colonne-1].lettre== lettre &&!recherche_redondance(redondance,ligne+1,colonne-1)){
empiler(ligne+1,colonne-1);
ajouter_coordonnee(redondance,ligne+1,colonne-1);
*k=*k+1;
}
//case ligne,colonne-1
else if(0<=colonne-1 && matrice[ligne][colonne-1].lettre== lettre && !recherche_redondance(redondance,ligne,colonne-1)){
empiler(ligne,colonne-1);
ajouter_coordonnee(redondance,ligne,colonne-1);
*k=*k+1;
}
//si la lettre recherchee n'est pas presente
else{
depiler();
if(*k>0) *k=*k-1;
}
}
int main(void)
{
creerPile();
empiler(42);
// 42
empiler(9);
// 9
// 42
int retour = depiler();
// retour = 9
return 0;
}
/*fonction recherche_mot_matrice
*utilisation des fonctions precedentes afin de rechercher un mot dans la matrice jeu
*retourne 1 si le mot donne en parametre est present
*retourne 0 dans le cas inverse
*/
int recherche_mot_matrice(char mot[20],t_case matrice[TAILLE_MATRICE][TAILLE_MATRICE]){
//declaration
int i;
int j;
int k=0;
//recherche d'une lettre à partir de la case (0;0)de la matrice jeu
for(i=0;i<TAILLE_MATRICE;i++){
for(j=0;j<TAILLE_MATRICE;j++){
if(matrice[i][j].lettre==mot[k]){
//declaration pour chaque départ d'une case
int p;
//initialisation:
//de la structure redondance à -1 pour toutes les lignes, initialisation avec une valeur impossible pour une coordonnees
for(p=0;p<TAILLE_MATRICE*TAILLE_MATRICE;p++){
redondance[p].ligne=-1;
}
//de la pile
initpile();
empiler(i,j);
k++;
//de la structure redondance
redondance[0].ligne=i;
redondance[0].colonne=j;
//traitement
while(sommet!=-1){
if(mot[k]=='\0')return 1;
chemin(matrice,mot[k],&k,redondance);
}
}
}
}
return 0;
}
void ass_fctCallJmp(char* fctName)
{
PRINT_DEBUG();
printInst("6 %d %d\n", ADDR_R1, 5);
printInst("10 %d\n", ADDR_R0); // R1 = adresse de retour
printInst("1 %d %d %d\n", ADDR_R0, ADDR_R0, ADDR_R1);
empiler(ADDR_R0);
printInst("7 .%s \n", fctName);
}
void get_file_info(char * path)
{
struct stat statfile;
stat(path, &statfile);
//void empiler(struct pile_file * pile, char * p, char * n, time_t * ct, ushort * mode, long * size);
long size = htonl(statfile.st_size);
empiler(list_file, path, "jose", (time_t *)&statfile.st_mtim, (ushort *)&statfile.st_mode, &size);
}
pEmploye chercherEmployePile(pPile p, int num)
{
pPile p2 = creerPile();
pEmploye pE=NULL;
pEmploye pE2=NULL;
if(p == NULL)
{
perror("erreur: pile.c : fonction chercherEmployePile: pointeur NULL");
return NULL;
}
if (pileVide(p)) {
printf("erreur: pile.c : fonction chercherEmployePile: la Pile est vide\n");
return NULL;
}
while(!pileVide(p))
{
pE2 = SommetEmploye(p);
if((pE2->num) == num)
{
pE = pE2;
break;
}
else
{
depiler(p);
empiler(p2,pE2);
}
}
while(!pileVide(p2))
{
pE2 = depiler(p2);
empiler(p,pE2);
}
supprimerPile(p2);
return pE;
}
void lecture_pile(lifo_t * p, char * ch)
{
/*variables locales*/
int compt = 0;
while (ch[compt] != '\0')
{
empiler(p,ch[compt]);
compt++;
}
}
/*@requires: n >= 0
@assigns: rien
@ensures: renvoie la factorielle de n*/
int factorielle(int n) {
if(n <= 0)
return 1;
pile p = creer_vide();
empiler(&p, n);
for(; n > 1; n--)
empiler_moins_un(&p);
return produit_pile(p);
}
static char do_patern_led(struct args_t *args) {
if(args) {
/*
* Patern 0 -> clear
* Patern 1 -> unie
* Patern 2 -> defilement
* Patern 3 -> empiler
* Patern 4 -> aller_retour
* Couleur 0 -> Clear
* Couleur 1 -> Bleu
* Couleur 2 -> Rouge
* Couleur 3 -> Vert
*/
INIT_WAIT;
SPI_INIT;
//On clear les LED
clear_led();
uint16_t coul = get_coul((int) args->couleur1);
uint16_t coul2 = get_coul((int) args->couleur2);
int patern = (int) args->patern;
int tour = (int) args->tour;
switch(patern){
case 0 :
clear_led();
break;
case 1 :
unie(coul);
break;
case 2 :
defilement_led(coul);
//On clear les LED
clear_led();
break;
case 3 :
empiler(coul, coul2, tour);
//On clear les LED
clear_led();
break;
case 4 :
allerRetour(coul, coul2, tour);
break;
//On clear les LED
clear_led();
default :
break;
}
}
return 0;
}
void appliqueCoup(char **plateau, Joueur *depart, Point arrivee, int mode) {
depart->score += plateau[arrivee.y][arrivee.x];
plateau[arrivee.y][arrivee.x] = plateau[depart->pion->pos.y][depart->pion->pos.x];
if (mode == SERPENT)
depart->pion->pos = arrivee;
else
depart->pion = empiler(depart->pion, arrivee);
}
/*
* Stocke le couple (identifiant, ensemble) dans la pile.
* Une recherche d'un couple avec le même identifiant a lieu.
* Si un tel couple existe, mise à jour de l'ensemble associé à cet identifiant.
* Sinon ajout dans la pile.
*/
void stocker (struct Pile * pile, unsigned int identifiant, unsigned int ensemble)
{
struct ElementPile * element = NULL;
if ((element = rechercher(pile, identifiant)) != NULL)
{
element->ensemble = ensemble;
}
else
{
empiler(pile, identifiant, ensemble);
}
}
void main () {
typePile *pile;
char expr [TAILLEMAX];
int val;
char *ptexpr;
typeNoeud *feuille, *noeud, *droit, *gauche;
typeNoeud *racine;
pile = initpile (TAILLEPILE);
ptexpr = expr;
printf ("Entrer une expression postfixee\n");
fgets (expr, TAILLEMAX, stdin);
while (*ptexpr == ' ') ptexpr++;
while ( *ptexpr != '=' && *ptexpr != '\n' ) {
if (!isdigit (*ptexpr)) {
droit = depiler(pile);
gauche = depiler(pile);
noeud = creerNoeud (*ptexpr, gauche, droit);
empiler (pile, noeud);
ptexpr++;
} else {
sscanf (ptexpr, "%d", &val);
while (isdigit(*ptexpr)) ptexpr++;
feuille = creerFeuille (val);
empiler (pile, feuille);
}
while (*ptexpr == ' ') ptexpr++;
}
racine = depiler(pile);
printf ("\nExpression infixee : \n");
infixe (racine);
printf ("\n\n");
printf ("Expression prefixee : \n");
prefixe (racine);
printf ("\n\n");
printf ("Valeur de l'expression : %d\n", eval (racine));
}
ElemPoint* creerPileCoupsPossibles(ElemPoint *pile, char **plateau, int taille, int mode, Point depart) {
if (depart.y > 0 && CASEVIDE(plateau[depart.y-1][depart.x])) // Haut
pile = empiler(pile, (Point){depart.x, depart.y-1});
if (depart.y < taille-1 && CASEVIDE(plateau[depart.y+1][depart.x])) // Bas
pile = empiler(pile, (Point){depart.x, depart.y+1});
if (depart.x > 0 && CASEVIDE(plateau[depart.y][depart.x-1])) // Gauche
pile = empiler(pile, (Point){depart.x-1, depart.y});
if (depart.x < taille-1 && CASEVIDE(plateau[depart.y][depart.x+1])) // Droite
pile = empiler(pile, (Point){depart.x+1, depart.y});
if (mode == PIEUVRE)
{
if (depart.x > 0 && depart.y > 0 && CASEVIDE(plateau[depart.y-1][depart.x-1])) // Gauche / Haut
pile = empiler(pile, (Point){depart.x-1, depart.y-1});
if (depart.x > 0 && depart.y < taille-1 && CASEVIDE(plateau[depart.y+1][depart.x-1])) // Gauche / Bas
pile = empiler(pile, (Point){depart.x-1, depart.y+1});
if (depart.x < taille-1 && depart.y > 0 && CASEVIDE(plateau[depart.y-1][depart.x+1])) // Droite / Haut
pile = empiler(pile, (Point){depart.x+1, depart.y-1});
if (depart.x < taille-1 && depart.y < taille-1 && CASEVIDE(plateau[depart.y+1][depart.x+1])) // Droite / Bas
pile = empiler(pile, (Point){depart.x+1, depart.y+1});
}
return pile;
}
void ass_fctBegin(char* fctName, int nbParams)
{
PRINT_DEBUG();
labelT_pushTableComplet(fctName, instructionNumber);
empiler(ADDR_CONTEXT); // sauver le contexte
printInst("5 %d %d\n", ADDR_CONTEXT, ADDR_SP); // CONTEXT = SP
symboleT_newBloc(); // parameters
char** tabParams = funT_getParamsByFunName(fctName);
for(int i=0; i<nbParams; i++)
{
symboleT_pushTable(tabParams[i], (-2-nbParams) + i );
}
symboleT_setSymboleNumber(0);
}
void test_pile()
{
int choix = 0;
int valeur;
int bool;
pile_t * lifo = NULL;
while(choix != -1)
{
printf("Fonctions de test de la pile\n");
printf("1) Initialisation de la pile\n");
printf("2) test si pile vide \n");
printf("3) test si pile pleine\n");
printf("4) empiler une valeur\n");
printf("5) depiler une valeur\n");
printf("6) valeur du sommet\n");
printf("autre: retour au menu\n");
scanf("%d",&choix);
switch(choix)
{
case 1:
printf("taille maximale souhaitee? \n");
scanf("%d",&valeur);
lifo = init_pile(valeur);
break;
case 2:
bool = vide_pile(lifo);
if(bool)
printf("pile vide\n");
else
printf("pile non vide\n");
break;
case 3:
bool = pleine_pile(lifo);
if(bool)
printf("pile pleine\n");
else
printf("pile non pleine\n");
break;
case 4:
printf("la valeur a empiler?\n");
scanf("%d",&valeur);
bool = empiler(lifo,valeur);
if(bool)
printf("empilation reussi\n");
else
void ass_declVar(char* varName, int arraySize)
{
PRINT_DEBUG();
int addr = symboleT_getSymboleNumber();
symboleT_pushTable(varName, addr);
if(arraySize <= 1)
empiler(ADDR_R0); // empiler varName
else
{
// traiter les tableaux
for(int i = 1; i < arraySize; i++)
symboleT_pushTable("", addr);
printInst("6 %d %d\n", ADDR_R0, arraySize); // R0 = arraySize
printInst("1 %d %d %d\n", ADDR_SP, ADDR_SP, ADDR_R0); // SP += arraySize
}
}
void inversion_pile(lifo_t * p)
{
/*variables locales*/
fifo_t * f = NULL; /*file*/
type_t tmp; /*valeurs a afficher*/
int err; /*erreur*/
/*initialisation*/
f = (fifo_t *)malloc(sizeof(fifo_t));
err = init_fifo(f,p->t_max);
if (! err)
{
printf("Pile a inverser :\n");
afficher_lifo(p);
/*parcours de la pile*/
while (!lifo_vide(p))
{
tmp = depiler(p); /*passage des valeurs*/
enfiler(f,tmp);
}
printf("Etat de la file :\n");
afficher_fifo(f);
while (! fifo_vide(f))
{
tmp = defiler(f); /*passage des valeurs*/
empiler(p,tmp);
}
/*liberation de la file*/
free_fifo(f);
}
printf("Pile inversee :\n");
afficher_lifo(p);
}
int comparer(char * exp)
{
int i=0;
int boolean=0;
Pile p=NULL;
while((&exp[i]!=NULL)&&(boolean!=0)){
if ((exp[i]=='{')||(exp[i]=='(')||(exp[i]=='[')){
empiler(&p,exp[i]);
i++;
}else if ((exp[i]=='}')&&(p->valeur=='{')){
depiler(&p);
i++;
}else if ((exp[i]==')')&&(p->valeur=='(')){
depiler(&p);
i++;
}else if ((exp[i]==']')&&(p->valeur=='[')){
depiler(&p);
i++;
}else{
boolean = 1;
return 1;
}
return 0;
}
int main(int argc, char * argv[])
{ int r;
printf("%s\n",argv[1]);
r =comparer(argv[1]);
printf("%d \n",r);
return 0;
}
void action(int act) {
nodeType *t1, *t2;
switch (act) {
case 1: //-----------nouvelle case tab
t1 = depiler();
t2 = depiler();
A[nameToIndexGPL(t2->name)] = t1;
tailleForet++;
break;
case 2: //-----------genAtom
empiler(genAtomGPL(recherche(dicos->dicoNT, NONTERMINAL, val_scan()),
action_scan(), NONTERMINAL));
break;
case 3: //-----------genUnion
t1 = depiler();
t2 = depiler();
empiler(genUnion(t2, t1));
break;
case 4: //-----------genConc
t1 = depiler();
t2 = depiler();
empiler(genConc(t2, t1));
break;
case 5: //-----------genAtome
empiler(genAtomGPL(recherche(dicos->dicoT, TERMINAL, val_scan()),
action_scan(), TERMINAL));
break;
case 6: //-----------genStar
t1 = depiler();
empiler(genStar(t1));
break;
case 7: //-----------genUn
t1 = depiler();
empiler(genUn(t1));
break;
default:
printf("erreur action numéro %d", act);
break;
}
}
t_graphe *parcours_profondeur(t_graphe* graphe, char *n_s)
{
int *visite;
int *names;
t_pile *pile;
int s;
int u;
int v;
int i;
int succ;
int size;
t_ch_int *tmp;
t_ch_ch_int *ttmp;
t_graphe *T;
void *data;
u = 0;
v = 0;
data = 0;
succ = 0;
size = taille(graphe);
visite = xmalloc(sizeof(*visite)*size);
names = xmalloc(sizeof(*names)*size);
pile = xmalloc(sizeof(*pile));
pile->pile = xmalloc(sizeof(*pile->pile)*size);
pile->taille_pile = 0;
T = init(GO);
empiler(name_to_number(graphe, n_s), pile);
for (i = 0, ttmp = graphe->graphe; i < size; i++, ttmp = ttmp->next)
names[i] = ttmp->number;
inserer(get_index(s, names, size), visite);
while (pile->taille_pile != 0)
{
u = sommet(pile);
succ = 0;
for (ttmp = graphe->graphe; ttmp != NULL; ttmp = ttmp->next)
if (ttmp->number == u)
break;
for (tmp = ttmp->liste; tmp != NULL; tmp = tmp->next)
if (!visite[get_index(tmp->number, names, size)])
succ++;
if (succ != 0)
{
for (ttmp = graphe->graphe; ttmp != NULL; ttmp = ttmp->next)
if (ttmp->number == u)
break;
for (tmp = ttmp->liste; tmp != NULL; tmp = tmp->next)
if (!visite[get_index(tmp->number, names, size)])
{
v = tmp->number;
data = tmp->data;
break;
}
ajouterArc(T, number_to_name(graphe, u), number_to_name(graphe, v), data);
empiler(v,pile);
inserer(get_index(v, names, size), visite);
}
else
depiler(pile);
}
return (T);
}
/* Fonction min-max permettant de déterminer ou jouer
- le meilleur coup est stocké dans *ti et *tj
- joueur est le joueur devant joue le meilleur coup
- joueur_actif est le joueur jouant le tour actuel
- depth = profondeur actuelle dans l'arbre de recherche
- max-depth = profondeur maximale, la récursion s'arrête si on l'atteind
*/
int min_max(othello* jeu, char joueur, char joueur_actif, int nb_coups, int*ti, int*tj, int depth, int max_depth){
int meilleur_score =-1;
int cur_score;
int i, j;
typedef struct coord_meilleur_coup{ int ligne; int colonne;} coord_MC; //structure des coordonnées d'un meilleur coup
int compteur_mc= 0; //compteur de meilleur coup
coord_MC tab[TAILLE*TAILLE]; /* tableau stockant chaque meilleur coup possible */
/* Si la partie est finie ou si on a atteind la profondeur maximale -> on renvoie le score du plateau */
if(partie_finie(nb_coups, 0)||depth == max_depth){
meilleur_score = score(jeu, joueur_actif, depth, nb_coups);
}
else {
//on parcours toutes les positions
for(i=0; i<TAILLE; i++){
for(j=0; j<TAILLE; j++){
//si on a un coup possible on renvoi le meilleur coup a jouer
if(coup_possible(jeu, joueur_actif, i, j)){
empiler(*jeu);
jouer_un_coup(jeu, joueur_actif, i, j);
cur_score = min_max(jeu, joueur, adversaire(joueur_actif), nb_coups+1, ti, tj, depth+1, max_depth);
depiler(jeu);
if(joueur_actif == joueur){
meilleur_score = -1000;
if(cur_score > meilleur_score){
meilleur_score = cur_score;
*ti = i;
*tj = j;
tab[compteur_mc].ligne = i;
tab[compteur_mc].colonne = j;
}
compteur_mc++;
}
if(joueur_actif == adversaire(joueur)){
meilleur_score = 1000;
if(cur_score < meilleur_score){
meilleur_score = cur_score;
*ti = i;
*tj = j;
tab[compteur_mc].ligne = i;
tab[compteur_mc].colonne = j;
}
compteur_mc++;
}
} //endif coup_possible()
}
}
if(compteur_mc > 0){
int al = rand()%compteur_mc;
*ti = tab[al].ligne;
*tj = tab[al].colonne;
}
else{
*ti =-1;
*tj =-1;
}
}
/* pour tous les coups possibles
sauvegarder le jeu (empiler)
jouer ce coup
score = appel récursif de min_max avec les paramètres mis à jour
restaurer le jeu (dépiler)
Si c'est à nous de jouer -> conserver le score max et le coup correspondant
Si c'est à l'adversaire de jouer -> conserver le score min et le coup correspondant
S'il y a au moins 1 meilleur coup possible
mettre le coup correspondant dans ti et tj
Amélioration : choisir aléatoirement un coup parmis les meilleurs possibles
Sinon
mettre -1,-1 dans ti et tj
renvoyer le score
*/
return meilleur_score;
}
/**
* @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);
}
int jouerUnCoup(TPartie *partie, Coord cible, int estJoueur){
Coup *tir = NULL;
TBateau *bateauCible = NULL;
Grille *grilleCible = NULL;
int idCible = -1;
int i;
int indexCaseBateauTouche;
//===========================================================================
//
// On récupère la cible.
//
//Si c'est le joueur qui tire, la cible est sur la grille de la machine
if(estJoueur){
grilleCible = partie->grilleMachine;
idCible = getIdBateauSurCase(grilleCible, cible);
tir = creerCoup(HUMAIN, cible);
}
//Sinon on tire sur la grillle du joueur
else{
grilleCible = partie->grille;
idCible = getIdBateauSurCase(grilleCible, cible);
tir = creerCoup(MACHINE, cible);
}
//===========================================================================
//
// On ajoute le coup à la pile des coups
//
globalPartie->pileCoups = empiler(globalPartie->pileCoups, tir);
//===========================================================================
//
// Traitement des effets du tir
//
//On retire 1 au score pour le coup tiré
partie->scorePlayer = partie->scorePlayer - 1;
//Si il n'y a pas de bateau, le tir ne touche personne
if(idCible < 0){
//On place la case à "à l'eau"
setEtatCase(grilleCible, cible, GRILLE_CASE_EAU);
return 0;
}
else{
//Si on touche un bateau
//On récupère le bateau cible
bateauCible = getBateauFromId(idCible);
//On détermine quelle case du bateau toucher
//Si le bateau est horizontal on calcule l'index de la case à toucher.
if(bateauCible->position.direction == HORIZONTAL){
indexCaseBateauTouche = cible.noCol-bateauCible->position.x;
}
//Si le bateau est vertical
else{
indexCaseBateauTouche = cible.noLin-bateauCible->position.y;
}
//On modifie la case touchée par le tir (etat touché)
toucherBateau(bateauCible, indexCaseBateauTouche);
//Si le bateau est coulé
if(estCoule(bateauCible)){
//On place toute ses cases à "coulé"
i = 0;
//On place la première coordonnée
cible.noCol = bateauCible->position.x;
cible.noLin = bateauCible->position.y;
while(i < getTypeBateau(bateauCible)){
//On place la case à touché
setEtatCase(grilleCible, cible, GRILLE_CASE_COULE);
if(bateauCible->position.direction == HORIZONTAL){
cible.noCol = cible.noCol+1;
}
else{
cible.noLin = cible.noLin+1;
}
i++;
}
return -1;
}
//Sinon il est juste touché
else{
//On modifie la case à "touché"
setEtatCase(grilleCible, cible, GRILLE_CASE_TOUCHE);
}
return 1;
}
}
// Lecture d'un fichier obj en mode texte, rapide
// Ces fichiers peuvent contenir des indices différents pour chaque attribut (vertex, uv, normal)
// OpenGl ne supporte pas cela, donc on désindexe les attributs en les mettant les uns à la suite des autres
bool loadIndexedObj(const char* filename, Vec3** vertices, Vec3** normals, Vec2** uvs, int* nb, Vec2** range, int* nbObjects, char*** matNames, char* mtlFile) {
printf("\tLoading OBJ file '%s' ...", filename);
FILE* file = fopen(filename, "r");
if (file == NULL)
{
puts("Error");
return false;
}
clock_t start = clock();
bool faceConstruction = false;
ElemVec3* listeVertex = NULL;
ElemVec3* listeUv = NULL;
ElemVec3* listeNormal = NULL;
ElemVec3* listeVertexIndices = NULL;
ElemVec3* listeUvIndices = NULL;
ElemVec3* listeNormalIndices = NULL;
ElemVec3* listeRange = NULL;
ElemString* listeMatNames = NULL;
char lineHeader[128] = "";
char currentMat[128] = "";
int currentIndex = 0;
int i;
Vec3 vecTemp;
while( 1 )
{
// read the first word of the line
int res = fscanf(file, "%s", lineHeader);
// Indices des données de chaque triangle
if ( strcmp( lineHeader, "f" ) == 0 && res != EOF)
{
if (faceConstruction == false)
{
faceConstruction = true;
listeRange = empiler(listeRange, Vec3_Create(currentIndex, 0, 0));
listeMatNames = empilerStr(listeMatNames, currentMat);
// Empile le nom du matériau actuel (usemtl)
// Empile un nouvel élém d'intervalle avec l'index actuel pour début
}
for (i = 0 ; i < 3 ; i++ )
{
int matches = fscanf(file, "%f/%f/%f ", &vecTemp.x, &vecTemp.y, &vecTemp.z );
if (matches != 3)
{
printf("File can't be read by our simple parser :-( Try exporting with other options\n");
return false;
}
listeVertexIndices = empiler(listeVertexIndices, (Vec3) {
vecTemp.x, 0, 0
});
listeUvIndices = empiler(listeUvIndices, (Vec3) {
vecTemp.y, 0, 0
});
listeNormalIndices = empiler(listeNormalIndices, (Vec3) {
vecTemp.z, 0, 0
});
}
currentIndex += 3;
}
else
{
if (faceConstruction == true && lineHeader[0] != 's')
{
faceConstruction = false;
// x Stocke l'index de départ, y stocke le nombre d'éléments
listeRange->vec.y = currentIndex - listeRange->vec.x;
// Met l'index de fin de l'intervalle actuel à la valeur actuelle de l'index
}
if (res == EOF)
break; // EOF = End Of File. Quit the loop.
// Vertex
if ( strcmp( lineHeader, "v" ) == 0 )
{
fscanf(file, "%f %f %f\n", &vecTemp.x, &vecTemp.y, &vecTemp.z );
listeVertex = empiler(listeVertex, vecTemp);
}
// Texture coordinate
else if ( strcmp( lineHeader, "vt" ) == 0 )
{
fscanf(file, "%f %f\n", &vecTemp.x, &vecTemp.y );
listeUv = empiler(listeUv, vecTemp);
}
// Normal
else if ( strcmp( lineHeader, "vn" ) == 0 )
{
fscanf(file, "%f %f %f\n", &vecTemp.x, &vecTemp.y, &vecTemp.z );
listeNormal = empiler(listeNormal, vecTemp);
}
// Material file
else if ( strcmp( lineHeader, "mtllib") == 0)
{
if (mtlFile != NULL)
fscanf(file, "%s", mtlFile);
}
// Material name
else if ( strcmp( lineHeader, "usemtl") == 0)
{
fscanf(file, "%s", currentMat);
}
else
{
// Probably a comment, eat up the rest of the line
char stupidBuffer[1000];
fgets(stupidBuffer, 1000, file);
}
}
}
fclose(file);
int nbVertexUniques = getElemNumber(listeVertexIndices);
// On dump les listes d'indices dans des tableaux pour accélérer les accès
unsigned int* vertexIndices = dumpListeToArray(listeVertexIndices);
unsigned int* normalIndices = dumpListeToArray(listeNormalIndices);
unsigned int* uvIndices = dumpListeToArray(listeUvIndices);
// On dump les listes de données dans des tableaux pour accélérer les accès
Vec3* verticesDump = dumpVec3ListeToArray(listeVertex);
Vec3* normalsDump = dumpVec3ListeToArray(listeNormal);
Vec2* uvsDump = dumpVec2ListeToArray(listeUv);
// On alloue les tableaux finaux, tous de la meme taille
*vertices = malloc(sizeof(Vec3) * nbVertexUniques);
*normals = malloc(sizeof(Vec3) * nbVertexUniques);
*uvs = malloc(sizeof(Vec2) * nbVertexUniques);
// Ici on va passer vertex par vertex
for( i = 0; i < nbVertexUniques; i++ )
{
// On va récupèrer les données dans les tableaux avec les indices
// Les données sont enregistrées dans les tableaux finaux
(*vertices)[i] = verticesDump[vertexIndices[i]-1];
(*normals) [i] = normalsDump[normalIndices[i]-1];
(*uvs) [i] = uvsDump[uvIndices[i]-1];
}
*nb = nbVertexUniques;
*nbObjects = getElemNumber(listeRange);
*range = dumpVec2ListeToArray(listeRange);
*matNames = dumpListeToArrayStr(listeMatNames);
free(vertexIndices);
free(normalIndices);
free(uvIndices);
free(verticesDump);
free(normalsDump);
free(uvsDump);
puts("Ok");
printf("\tRead %d vertices, %d objects\n", nbVertexUniques, *nbObjects);
printf("\tTime used: %.3f seconds\n", ((float)clock() - start) / CLOCKS_PER_SEC);
return true;
}
bool loadMtl(char* filename, Material** material, int* nbFinal) {
printf("\tLoading MTL file '%s'\n", filename);
FILE* file = fopen(filename, "r");
if (file == NULL)
{
puts("Error");
return false;
}
clock_t start = clock();
ElemString* pileName = NULL;
ElemString* pileTexture = NULL;
ElemString* pileNormalMap = NULL;
ElemString* pileSpecularMap = NULL;
ElemVec3* pileAmbient = NULL;
ElemVec3* pileDiffuse = NULL;
ElemVec3* pileSpecular = NULL;
ElemVec3* pileExponent = NULL;
char lineHeader[128];
char chaine[128] = "";
Vec3 vecTemp;
int i;
bool mtlIsBeingDefined = false;
while( 1 )
{
// read the first word of the line
int res = fscanf(file, "%s", lineHeader);
// Nouveau matériau, on stocke le nom
if ( stricmp( lineHeader, "newmtl" ) == 0 && res != EOF)
{
if (mtlIsBeingDefined == false)
{
mtlIsBeingDefined = true;
}
fscanf(file, "%s", chaine);
pileName = empilerStr(pileName, chaine);
pileTexture = empilerStr(pileTexture, "");
pileNormalMap = empilerStr(pileNormalMap, "");
pileSpecularMap = empilerStr(pileSpecularMap, "");
pileExponent = empiler(pileExponent, (Vec3) {
20, 0, 0
});
pileSpecular = empiler(pileSpecular, (Vec3) {
1, 1, 1
});
pileDiffuse = empiler(pileDiffuse, (Vec3) {
1, 1, 1
});
pileAmbient = empiler(pileAmbient, (Vec3) {
1, 1, 1
});
}
else
{
if (mtlIsBeingDefined)
{
mtlIsBeingDefined = false;
}
// EOF = End Of File. Quit the loop.
if (res == EOF)
break;
// Texture diffuse
else if ( stricmp( lineHeader, "map_Kd" ) == 0 )
{
fscanf(file, "%s", chaine);
strcpy(pileTexture->chaine, chaine);
}
// Normal map
else if ( stricmp( lineHeader, "map_bump" ) == 0 || stricmp( lineHeader, "map_Disp" ) == 0 )
{
fscanf(file, "%s", chaine);
strcpy(pileNormalMap->chaine, chaine);
}
// Specular map
else if ( stricmp( lineHeader, "map_Ks" ) == 0)
{
fscanf(file, "%s", chaine);
strcpy(pileSpecularMap->chaine, chaine);
}
// Couleur ambiante
else if ( stricmp( lineHeader, "Ka") == 0)
{
fscanf(file, "%f %f %f", &vecTemp.x, &vecTemp.y, &vecTemp.z );
pileAmbient->vec = vecTemp;
}
// Couleur diffuse
else if ( stricmp( lineHeader, "Kd") == 0)
{
fscanf(file, "%f %f %f", &vecTemp.x, &vecTemp.y, &vecTemp.z );
pileDiffuse->vec = vecTemp;
}
// Couleur spéculaire
else if ( stricmp( lineHeader, "Ks" ) == 0 )
{
fscanf(file, "%f %f %f\n", &vecTemp.x, &vecTemp.y, &vecTemp.z );
pileSpecular->vec = vecTemp;
}
// Exponent spéculaire
else if ( stricmp( lineHeader, "Ns" ) == 0 )
{
fscanf(file, "%f", &vecTemp.x);
pileExponent->vec = vecTemp;
}
else
{
// Probably a comment, eat up the rest of the line
char stupidBuffer[1000];
fgets(stupidBuffer, 1000, file);
}
}
}
int nb = getElemNumberStr(pileName);
char** names = dumpListeToArrayStr(pileName);
char** textures = dumpListeToArrayStr(pileTexture);
char** normalMaps = dumpListeToArrayStr(pileNormalMap);
char** specularMaps = dumpListeToArrayStr(pileSpecularMap);
Vec3* ambient = dumpVec3ListeToArray(pileAmbient);
Vec3* diffuse = dumpVec3ListeToArray(pileDiffuse);
Vec3* specular = dumpVec3ListeToArray(pileSpecular);
unsigned int* exponent = dumpListeToArray(pileExponent);
*material = malloc(sizeof(Material) * nb);
for (i = 0 ; i < nb ; i++ )
{
(*material)[i].type = NONE;
strcpy((*material)[i].nom, names[i]);
if (strlen(textures[i]) > 0)
{
(*material)[i].texture = chargerTexture(textures[i], GL_LINEAR_MIPMAP_LINEAR);
(*material)[i].type |= COLOR_MAP;
}
if (strlen(normalMaps[i]) > 0)
{
(*material)[i].normalMap = chargerTexture(normalMaps[i], GL_LINEAR_MIPMAP_LINEAR);
(*material)[i].type |= NORMAL_MAP;
}
if (strlen(specularMaps[i]) > 0)
{
(*material)[i].specularMap = chargerTexture(specularMaps[i], GL_LINEAR);
(*material)[i].type |= SPECULAR_MAP;
}
if ((*material)[i].type == NONE)
{
(*material)[i].shader = ShaderLibrary_Get("noTexNoLight");
printf("Shader noTexNoLight choosen for [%s]\n", names[i]);
}
else
{
(*material)[i].shader = ShaderLibrary_Get("fullset");
printf("Shader fullset choosen for [%s]\n", names[i]);
}
(*material)[i].ambient = ambient[i];
(*material)[i].diffuse = diffuse[i];
(*material)[i].specular = specular[i];
(*material)[i].exponent = exponent[i];
}
*nbFinal = nb;
fclose(file);
puts("Ok");
printf("\t%d Materials loaded, ", nb);
printf("time used: %.3f seconds\n", ((float)clock() - start) / CLOCKS_PER_SEC);
return true;
}