Ajout de la derniere fonction de Empiler 3/3

SwichGIT/src/debug.log

@@ -1 +1,2 @@
 [1111/102926.535:ERROR:directory_reader_win.cc(43)] FindFirstFile: Le chemin d’accès spécifié est introuvable. (0x3)
+[1120/122821.005:ERROR:directory_reader_win.cc(43)] FindFirstFile: Le chemin d’accès spécifié est introuvable. (0x3)

SwichGIT/src/js/main.js

@@ -352,16 +352,27 @@ function remplacerLaCarte(uneCarte) {
 //====================================================================================
 //GESTION DE MATRICE
 
-function somMatrice(matrice1, matrice2) {
+function somMatrice(matrice1, matrice2, row, column) {
-	var somMatrice = creaMatriceVierge(matrice1.length, matrice1[0].length);
+	var somMatrice = creaMatriceVierge(row, column);
-	for (var i = 0; i < matrice1.length; i++) {
+	for (var i = 0; i < column; i++) {
-		for (var j = 0; j < matrice1[i].length; j++) {
+		for (var j = 0; j < row; j++) {
 			somMatrice[i][j] = matrice1[i][j] + matrice2[i][j];
 		}
 	}
 	return somMatrice;
 }
 
+function copieMatrice(laMatrice, row, column) {
+	var myMatrice = new Array();
+	for (var i = 0; i < column; i++) {
+		myMatrice[i] = new Array();
+		for (var j = 0; j < row; j++) {
+			myMatrice[i][j] = laMatrice[i][j];
+		}
+	}
+	return myMatrice;
+}
+
 function getRandom(min, max) {
 	return Math.round(Math.random() * (max - min) + min)
 }
@@ -411,17 +422,73 @@ function test() {
 	} else if (carteselect.length < 2) {
 		window.alert("Selection Trop Petite");
 		return;
-	} else if (carteselect.length > 2) {
-		window.alert("Selection Trop Grande");
-		return;
 	} else {
-		var tab = comparaisonTotal(carteselect[0], carteselect[1], 0);
+		var copie = [];
-		window.alert(tab[0])
+		for (var i = 0; i < carteselect.length; i++) {
-		window.alert(tab[1].getMatrice)
+			copie.push(carteselect[i]);
+		}
+		/*var tab = comparaisonTotal(carteselect[0], carteselect[1], 0);
+		window.alert("Code Final: " + tab[0] + "\nMatrice Final :" + tab[1].Matrice)
+		*/
+		var tab = assemblage(copie, null);
+		window.alert("Code Final " + tab[0]);
 		changerlesCartes();
+
+	}
+}
+
+function copieListeDeCarte(Liste) {
+	var copie = [];
+	for (var i = 0; i < Liste.length; i++) {
+		copie.push(copieCarte(Liste[i]));
 	}
+	return copie;
 }
 
+
+
+function copieCarte(uneCarte) {
+	if (uneCarte == null) {
+		return null;
+	}
+	var carte = new Carte(uneCarte.getIdentifiant);
+	carte.FigCreuse.forme = uneCarte.FigCreuse.forme;
+	carte.FigPleine.forme = uneCarte.FigPleine.forme;
+	carte.FigCreuse.type = uneCarte.FigCreuse.type;
+	carte.FigPleine.type = uneCarte.FigPleine.type;
+	carte.FigCreuse.X = uneCarte.FigCreuse.X;
+	carte.FigPleine.X = uneCarte.FigPleine.X;
+	carte.FigCreuse.Y = uneCarte.FigCreuse.Y;
+	carte.FigPleine.Y = uneCarte.FigPleine.Y;
+	carte.Matrice = copieMatrice(uneCarte.Matrice, uneCarte.row, uneCarte.column);
+	return carte;
+}
+
+
+
+
+
+
+/*function carteVerticale(uneCarte){
+
+	// Copie de la Carte d'origine
+	var carteVerticale = uneCarte;
+
+	carteVerticale.FigCreuse.X = carteVerticale.column - carteVerticale.FigCreuse.X - 1;
+	// Coordonnees Y ne changent pas => Verticale
+	carteVerticale.FigPleine.X = carteVerticale.column - carteVerticale.FigPleine.X - 1;
+	// Coordonnees Y ne changent pas => Verticale
+
+	carteVerticale.Matrice = creaMatriceVierge(carteVerticale.row, carteVerticale.column);
+	//Une figure pleine est signalée par un 1 dans la matrice de la carte.
+	carteVerticale.Matrice[carteVerticale.FigPleine.X][carteVerticale.FigPleine.Y] = 1;
+	//Une figure creuse est signalée par un 2 dans la matrice de la carte.
+	carteVerticale.Matrice[carteVerticale.FigCreuse.X][carteVerticale.FigCreuse.Y] = 2;
+
+
+	return carteVerticale;
+}*/
+
 //==============================================================================================================================
 
 //FONCTION POUR LISTE
@@ -458,19 +525,104 @@ function comparaisonDeCarte(CarteMere, CarteFille) {
 	return Code;
 
 }
+function comparaisonTotalTest(CarteMere, CarteFilleEntree, index) {
+	var CarteFille = copieCarte(CarteFilleEntree);
+	var tabRetour = [];
+
+	if (CarteMere == null) {
+		tabRetour.push(1);
+		tabRetour.push(CarteFille);
+		return tabRetour;
+	}
+	Code1 = comparaisonDeCarte(CarteMere, CarteFille);
+	if (Code1 == 2) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code1);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	Code2 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteVerticale);
+	if (Code2 == 2) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code2);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	Code3 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteHorizontale);
+	if (Code3 == 2) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteHorizontale.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code3);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	Code4 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteVerticale.carteHorizontale);
+	if (Code4 == 2) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteHorizontale.carteVerticale.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code4);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	//window.alert(Code1 + " " + Code2 + " " + Code3 + " " + Code4 + "\n" + CarteFille.Matrice + "\n" + CarteMere.Matrice)
+	if ((Code1 == 1) && (Code2 == 1)) {
+		tabRetour.push(3);
+		tabRetour.push(CarteFille.carteVerticale);
+		return tabRetour;
+	}
+	if ((Code3 == 1) && (Code4 == 1)) {
+		tabRetour.push(3);
+		tabRetour.push(CarteFille.carteHorizontale);
+		return tabRetour;
+	}
+	if ((Code1 == 1) && (Code3 == 1)) {
+		tabRetour.push(4);
+		tabRetour.push(CarteFille.carteHorizontale);
+		return tabRetour;
+	}
+	if (Code1 == 1) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code1);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	if (Code2 == 1) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code2);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	if (Code3 == 1) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteHorizontale.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code3);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	if (Code4 == 1) {
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.carteHorizontale.Matrice, CarteMere.row, CarteMere.column);
+		tabRetour.push(Code4);
+		tabRetour.push(CarteMere);
+		return tabRetour;
+	}
+	tabRetour.push(-1);
+	tabRetour.push(CarteMere);
+	return tabRetour;
 
 
-function comparaisonTotal(CarteMere, CarteFille, index) {
+}
+
+function comparaisonTotal(CarteMere, CarteFilleEntree, index) {
 	/*matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 1
 	matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y]*/
+	var CarteFille = copieCarte(CarteFilleEntree);
 	var Code1 = 0;
 	var Code2 = 0;
 	var tabRetour = [];
+
 	if (CarteMere == null) {
 		tabRetour.push(1);
 		tabRetour.push(CarteFille);
 		return tabRetour;
 	}
+
 	// NOTE : Cette fonction sait combien de fois elle a été appelée grâce à la variable index. 
 	//En effet pour une carte donnée il existe 4 variantes d'elle-même. 
 	//La fonction va donc appeler au fur et à mesure toutes ses variantes et 
@@ -495,7 +647,7 @@ function comparaisonTotal(CarteMere, CarteFille, index) {
 	Code1 = comparaisonDeCarte(CarteMere, CarteFille);
 
 	if (Code1 == 2) {
-		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice);
+		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column);
 		tabRetour.push(Code1);
 		tabRetour.push(CarteMere);
 		return tabRetour;
@@ -503,16 +655,29 @@ function comparaisonTotal(CarteMere, CarteFille, index) {
 	if (Code1 == 1) {
 		// NOTE : il est important de vérifier ce cas présent. En effet si une seule liaison est possible, certaines cartes offrent plusieurs possibilités d'assemblage impliquant deux variantes. Comment savoir laquelle est la bonne pour le tas final ? 
 		//La fonction va le faire remarquer.
-
+		Code2 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteHorizontale);
-		Code2 = comparaisonDeCarte(CarteMere, CarteFille.carteHorizontale);
 		if (Code2 == 2) {
-			CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteHorizontale.Matrice);
+			CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteHorizontale.Matrice, CarteMere.row, CarteMere.column);
 			tabRetour.push(Code2);
 			tabRetour.push(CarteMere);
 			return tabRetour;
 		}
 
 		if (Code2 == 1) {
+			var Code3 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteVerticale);
+			var Code4 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteVerticale.carteHorizontale)
+			if (Code3 == 2) {
+				tabRetour.push(2);
+				CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.Matrice, CarteMere.row, CarteMere.column);
+				tabRetour.push(CarteMere);
+				return tabRetour;
+			}
+			if (Code4 == 2) {
+				tabRetour.push(2);
+				CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.carteHorizontale.Matrice, CarteMere.row, CarteMere.column);
+				tabRetour.push(CarteMere);
+				return tabRetour;
+			}
 			// Les variantes horizontalement symétriques possèdent toutes les deux une liaison avec 
 			//CarteMere on ne peut pas savoir laquelle est la bonne pour faire le tas final.
 			tabRetour.push(4);
@@ -522,9 +687,9 @@ function comparaisonTotal(CarteMere, CarteFille, index) {
 
 		// On teste maintenant avec la variante verticalement symétrique
 
-		Code2 = comparaisonDeCarte(CarteMere, CarteFille.carteHorizontale.carteVerticale);
+		Code2 = comparaisonDeCarte(CarteMere, copieCarte(CarteFille).carteVerticale);
 		if (Code2 == 2) {
-			CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.Matrice);
+			CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.carteVerticale.Matrice, CarteMere.row, CarteMere.column);
 			tabRetour.push(Code2);
 			tabRetour.push(CarteMere);
 			return tabRetour;
@@ -537,10 +702,9 @@ function comparaisonTotal(CarteMere, CarteFille, index) {
 			tabRetour.push(CarteFille);
 			return tabRetour;
 		}
-		CarteFille.carteVerticale;
+		CarteFille.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column);
-		CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice);
 		tabRetour.push(Code1);
-		tabRetour.push(CarteMere);
+		tabRetour.push(CarteFille);
 		return tabRetour;
 	}
 
@@ -551,80 +715,111 @@ function comparaisonTotal(CarteMere, CarteFille, index) {
 
 //Assemblage
 
-function assemblage(carteselect, carteMere) {
+function assemblage(carteselect, carteMereEntree) {
 	var Carte;
-	var CopieCarteMere = carteMere;;
+	var carteMere = copieCarte(carteMereEntree);
-	var CarteParallele;
+	var CopieCarteMere;
+	var CarteParallele1;
+	var CarteParallele2;
 	var TabComparaison; //tab pour receptionner comparaison total
 	var TabRetour = []; //tab pour renvoyer code et carteMere
 	var TabRetourAss = []; //Tab retour pour l'appel récurssive de assemblage
 	var TabRetourAss1 = []; //2e Tab retour pour l'appel récurssive de assemblage
 
-	if (carteselect != null) {
+	if (carteselect.length == 0) {
 		TabRetour.push(0);
 		TabRetour.push(carteMere);
 		return TabRetour;
 	}
 
 	else {
-		Carte = carteselect[0];
+		Carte = copieCarte(carteselect[0]);
-		CopieCarteMere = carteMere;
+		CopieCarteMere = copieCarte(carteMere);
-		TabComparaison = comparaisonTotal(carteMere, Carte, 0);
+		/*if (CopieCarteMere != null) {
+			window.alert("Copie Carte Mere faite\n" + CopieCarteMere.Matrice);
+        }*/
+		carteselect.shift();
+		TabComparaison = comparaisonTotalTest(carteMere, Carte, 0);
 	}
-	if (TabComparaison[0] == 2 && carteselect == null) {
+
+	// En fonction du Résultat obtenue on traite
+
+	// Cas 1 : Si Code vaut 2 et que TasDeCarte est NULL on a atteint la 
+	//fin du paquet et l'assemblage est parfait
+
+	if (TabComparaison[0] == 2 && carteselect.length == 0) {
 		TabRetour.push(2);
 		TabRetour.push(carteMere);
 		return TabRetour;
 	}
-	if (carteselect == null && TabComparaison[0] != 2) {
+	// Cas 2 : TasDeCarte est NULL mais l'assemblage n'est pas parfait. On ne peut pas assembler
+	//correctement le tas de carte.On le signal
+
+	if (carteselect.length == 0 && TabComparaison[0] != 2) {
 		TabRetour.push(0);
 		TabRetour.push(carteMere);
 		return TabRetour;
 	}
+	// NOTE : à ce stade si l'algorithme lit ces lignes nous savons que TasDeCarte n'est pas NULL. Seul la valeur de Code retourné par **ComparaisonTotal nous interesse
+
+	//Cas 3 : Code vaut 2 ou 0, l'assemblage est parfait ou impossible mais il reste des cartes à traiter. Il faut donc insérer cette carte à la fin de la liste
+	//et continuer en traitant les autres carte.
+
 
 	if (TabComparaison[0] == 2 || TabComparaison[0] == 0 || TabComparaison[0] == -1) {
-		carteselect.push(carteselect, Carte);
+		carteselect.push(Carte);
 		return assemblage(carteselect, CopieCarteMere);
 	}
 
 	if (TabComparaison[0] == 3) {
-		CarteParallele = carteMere;
+		CarteParallele1 = copieCarte(TabComparaison[1]);
-		//pb tabRetour ?
+		CarteParallele1.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele1.Matrice, CopieCarteMere.row, CopieCarteMere.column);
-		TabRetourAss = assemblage(carteselect, CopieCarteMere + CarteParallele);
+		TabRetourAss = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele1));
-		TabRetourAss1 = assemblage(carteselect, CopieCarteMere + CarteParallele.carteVerticale);
-		if (TabRetourAss1[0] == 2) {
-			TabRetour.push(2);
-			TabRetour.push(TabRetourAss1[1]);
-			return TabRetour;
-		}
 		if (TabRetourAss[0] == 2) {
 			TabRetour.push(2);
 			TabRetour.push(TabRetourAss[1]);
 			return TabRetour;
 		}
+
+		CarteParallele2 = copieCarte(TabComparaison[1]).carteVerticale;
+		CarteParallele2.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele2.Matrice, CopieCarteMere.row, CopieCarteMere.column);
+		TabRetourAss1 = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele2));
+		if (TabRetourAss1[0] == 2) {
 			TabRetour.push(2);
+			TabRetour.push(TabRetourAss1[1]);
+			return TabRetour;
+		}
+		//pb tabRetour ?
+		TabRetour.push(0);
 		TabRetour.push(carteMere);
 		return TabRetour;
 	}
 
 	if (TabComparaison[0] == 4) {
-		CarteParallele = carteMere;
+		window.alert(TabComparaison[1].Matrice)
-		TabRetourAss = assemblage(carteselect, CopieCarteMere + CarteParallele);
+		CarteParallele1 = copieCarte(TabComparaison[1]);
-		TabRetourAss1 = assemblage(carteselect, CopieCarteMere + CarteParallele.carteHorizontale);
+		CarteParallele1.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele1.Matrice, CopieCarteMere.row, CopieCarteMere.column);
-		if (TabRetourAss1[0] == 2) {
+		TabRetourAss = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele1));
+
+		if (TabRetourAss[0] == 2) {
 			TabRetour.push(2);
-			TabRetour.push(TabRetourAss1[1]);
+			TabRetour.push(TabRetourAss[1]);
 			return TabRetour;
 		}
-		if (TabRetourAss[0] == 2) {
+		CarteParallele2 = copieCarte(TabComparaison[1]).carteHorizontale;
+		CarteParallele2.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele2.Matrice, CopieCarteMere.row, CopieCarteMere.column);
+		TabRetourAss1 = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele2));
+		if (TabRetourAss1[0] == 2) {
 			TabRetour.push(2);
-			TabRetour.push(TabRetourAss[1]);
+			TabRetour.push(TabRetourAss1[1]);
 			return TabRetour;
 		}
+		TabRetour.push(0);
+		TabRetour.push(TabRetourAss1[1]);
+		return TabRetour;
 	}
-
 	if (TabComparaison[0] == 1) {
-		return assemblage(carteselect, carteMere);
+		return assemblage(copieListeDeCarte(carteselect), TabComparaison[1]);
 	}
 
 }