//OK
void detruire(Arbre* racine)
{
if(racine != NULL)
{
detruire(racine->gauche);
detruire(racine->droit);
free(racine);
}
}
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;
}
void Map::BBexp(int i, int j, int puiss)
{
int X(0);
bool u;
(*(carte[i][j])).pObjet(0);
(*((*(bcarte[i][j])).getPerso())).bexp();
if (((*J1).getID() != 0) && ((*J1).geti() == i) && ((*J1).getj() == j)){ (*J1).pervie(); }
if (((*J2).getID() != 0) && ((*J2).geti() == i) && ((*J2).getj() == j)){ (*J2).pervie(); }
if (((*J3).getID() != 0) && ((*J3).geti() == i) && ((*J3).getj() == j)){ (*J3).pervie(); }
if (((*J4).getID() != 0) && ((*J4).geti() == i) && ((*J4).getj() == j)){ (*J4).pervie(); }
u = true;
X = i+1;
while (u && (X < mini(12, (i + 1 + puiss))))
{
u = detruire(X, j);
(*hori).render(X*45, j*45, *gRenderer);
X += 1;
}
u = true;
X = i-1;
while (u && (X > maxi(-1, (i - puiss-1))))
{
u = detruire(X, j);
(*hori).render(X * 45, j * 45, *gRenderer);
X =X -1;
}
u = true;
X = j+1;
while (u && (X < mini(12, (j+ 1 + puiss))))
{
u = detruire(i, X);
(*vert).render(i * 45, X * 45, *gRenderer);
X += 1;
}
u = true;
X = j-1;
while (u && (X >maxi(-1, (j - puiss-1))))
{
u = detruire(i, X);
(*vert).render(i * 45, X * 45, *gRenderer);
X = X-1;
}
}
//Détruit récursivement tous les pointeurs
void ArbreCompletion::detruire(Noeud* noeud) {
if (noeud != NULL)
{
for (unsigned int i = 0; i < noeud->getEnfants().size(); i++)
detruire(noeud->getEnfants()[i]);
delete noeud;
noeud = NULL;
}
}
ArbreCompletion::~ArbreCompletion() {
detruire(racine);
}
/**
* @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 Détruit le puzzle
* @see initialiser Le Puzzle doit déjà avoir été initialisé
* @param[in,out] p le puzzle à détruire
*/
void detruire(Puzzle& p) {
detruire(p.lEAE);
detruire(p.lEE);
}
CMsg::~CMsg()
{
detruire();
} // destructeur
Shader::~Shader()
{
detruire();
}