diff --git a/SwichGIT/src/js/main.js b/SwichGIT/src/js/main.js
index 3e9987f..754c573 100644
--- a/SwichGIT/src/js/main.js
+++ b/SwichGIT/src/js/main.js
@@ -18,6 +18,7 @@ class Carte {
 		this.row = 4 /*row*/;
 		this.column = 3 /*column*/;
 		this.Matrice = creaMatrice(this.row, this.column);
+		this.SesFigures = [];
 
 		//lien clicable
 		this.link = document.createElement('a');
@@ -37,8 +38,8 @@ class Carte {
 			if (this.Matrice[i % 3][Math.floor(i / 3)] == 1) {
 
 				//TEST : CRéation d'une figure Pleine => Rond
-				var uneFigure = new Figure(TypeFigure.Pleine, FormeFigure.Rond, i % 3, Math.floor(i / 3));
-				this.FigPleine = uneFigure;
+				var uneFigure = new Figure(TypeFigure.Petit, FormeFigure.Rond, i % 3, Math.floor(i / 3));
+				this.SesFigures.push(uneFigure);
 
 				divconteneur.appendChild(uneFigure.getHTML);
 
@@ -47,10 +48,10 @@ class Carte {
 
 				//TEST : CRéation d'une figure Pleine => Anneau
 
-				var uneFigure = new Figure(TypeFigure.Creuse, FormeFigure.Rond, i % 3, Math.floor(i / 3));
+				var uneFigure = new Figure(TypeFigure.Moyen, FormeFigure.Rond, i % 3, Math.floor(i / 3));
 
 
-				this.FigCreuse = uneFigure;
+				this.SesFigures.push(uneFigure);
 
 				divconteneur.appendChild(uneFigure.getHTML);
 
@@ -86,42 +87,47 @@ class Carte {
 
 	get carteVerticale() {
 
-		// Copie de la Carte d'origine
-		var carteVerticale = this;
-
-		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
+		for (var i = 0; i < this.SesFigures.length; i++) {
+			this.SesFigures[i].X = this.column - this.SesFigures[i].X - 1;
+		}
 
-		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;
+		this.Matrice = creaMatriceVierge(this.row, this.column);
 
+		for (var i = 0; i < this.SesFigures.length; i++) {
+			for (var j = 0; j < this.SesFigures[i].type.length; j++) {
+				if (this.SesFigures[i].type[j] == TypeFigure.Petit) {
+					this.Matrice[this.SesFigures[i].X][this.SesFigures[i].Y] += 1;
+				} else if (this.SesFigures[i].type[j] == TypeFigure.Moyen) {
+					this.Matrice[this.SesFigures[i].X][this.SesFigures[i].Y] += 2;
+				} else if (this.SesFigures[i].type[j] == TypeFigure.Grand) {
+					this.Matrice[this.SesFigures[i].X][this.SesFigures[i].Y] += 4;
+				}
+			}
+		}
+		return this;
 
-		return carteVerticale;
 	}
 
 	get carteHorizontale() {
 
-		//Copie de la carte d'origine
-		var carteHorizontale = this;
-
-		carteHorizontale.FigCreuse.Y = carteHorizontale.row - carteHorizontale.FigCreuse.Y - 1;
-
-		//Coordonnees X ne changent pas => Horizontale
-		carteHorizontale.FigPleine.Y = carteHorizontale.row - carteHorizontale.FigPleine.Y - 1;
-		//Coordonnees X ne changent pas => Horizontale
+		for (var i = 0; i < this.SesFigures.length; i++) {
+			this.SesFigures[i].Y = this.row - this.SesFigures[i].Y - 1;
+		}
 
-		carteHorizontale.Matrice = creaMatriceVierge(carteHorizontale.row, carteHorizontale.column);
-		//Une figure pleine est signalée par un 1 dans la matrice de la carte.
-		carteHorizontale.Matrice[carteHorizontale.FigPleine.X][carteHorizontale.FigPleine.Y] = 1;
-		//Une figure creuse est signalée par un 2 dans la matrice de la carte.
-		carteHorizontale.Matrice[carteHorizontale.FigCreuse.X][carteHorizontale.FigCreuse.Y] = 2;
+		this.Matrice = creaMatriceVierge(this.row, this.column);
 
-		return carteHorizontale;
+		for (var i = 0; i < this.SesFigures.length; i++) {
+			for (var j = 0; j < this.SesFigures[i].type.length; j++) {
+				if (this.SesFigures[i].type[j] == TypeFigure.Petit) {
+					this.Matrice[this.SesFigures[i].X][this.SesFigures[i].Y] += 1;
+				} else if (this.SesFigures[i].type[j] == TypeFigure.Moyen) {
+					this.Matrice[this.SesFigures[i].X][this.SesFigures[i].Y] += 2;
+				} else if (this.SesFigures[i].type[j] == TypeFigure.Grand) {
+					this.Matrice[this.SesFigures[i].X][this.SesFigures[i].Y] += 4;
+				}
+			}
+		}
+		return this;
 	}
 
 	get getHTML() {
@@ -136,30 +142,27 @@ class Carte {
 		return this.Matrice;
 	}
 
-	get getFigurePleine() {
-		return this.FigPleine;
-	}
-
-	get getFigureCreuse() {
-		return this.FigCreuse;
+	get getSesFigures() {
+		return this.SesFigures;
 	}
 }
 
 class Figure {
 
-	constructor(type, forme, Cox, Coy) {
+	constructor(leType, forme, Cox, Coy) {
 		this.X = Cox;
 		this.Y = Coy;
-		this.type = type;
+		this.type = [];
+		this.type.push(leType);
 		this.forme = forme;
 		var pos = this.X + this.Y * 3;
 		var divcase = document.createElement('div');
 		divcase.className = "item-form";
 		switch (this.forme) {
 			case FormeFigure.Rond:
-				switch (this.type) {
+				switch (this.type[0]) {
 
-					case TypeFigure.Creuse:
+					case TypeFigure.Moyen:
 
 						var divContainForm = document.createElement('div');
 						divContainForm.className = "containform";
@@ -186,7 +189,7 @@ class Figure {
 						this.CodeHTML = divcase;
 						break;
 
-					case TypeFigure.Pleine:
+					case TypeFigure.Petit:
 
 						var divContainForm = document.createElement('div');
 						divContainForm.className = "containform";
@@ -239,8 +242,9 @@ const FormeFigure = {
 };
 
 const TypeFigure = {
-	Pleine: 'pleine',
-	Creuse: 'creuse'
+	Petit: 'petit',
+	Moyen: 'moyen',
+	Grand: 'grand'
 };
 
 
@@ -325,7 +329,7 @@ function creePartie() {
 	while (document.getElementById("containcards").firstElementChild != null) {
 		document.getElementById("containcards").firstElementChild.remove();
 	}
-	for (var j = 1; j <= 16; j++) {
+	for (var j = 1; j <= 32; j++) {
 
 		var uneCarte = new Carte(j);
 
@@ -427,13 +431,30 @@ function test() {
 			for (var i = 0; i < carteselect.length; i++) {
 				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]);
-			if (tab[0] == 2) {
-				changerlesCartes();
+
+			/*var uneTable = copieListeDeCarte(copie);
+			uneTable.splice(0, 1);
+			var TEST = AssemblageARBRE(uneTable, copie[0]);
+			changerlesCartes();*/
+			var tab = [];
+			tab = AssemblageARBRE(copieListeDeCarte(copie), carteselect[0]);
+			var solution = true;
+			var tabCode = [];
+			for (var i = 0; i < tab.length; i++) {
+				tabCode.push(tab[i].code);
+			}
+			//window.alert(tabCode)
+			for (var i = 0; i < tab.length; i++) {
+				if (tab[i].code == copie.length) {
+					solution = false;
+					changerlesCartes();
+				}
+			}
+			if (solution) {
+				window.alert("Rien trouvé chef !!!");
+			}
+			if (!solution) {
+				window.alert("J'ai une solution chef !!!!");
 			}
 
 		}
@@ -441,6 +462,7 @@ function test() {
 		window.alert("Assemblage Impossible");
 	}
 }
+
 function copieListeDeCarte(Liste) {
 	var copie = [];
 	for (var i = 0; i < Liste.length; i++) {
@@ -448,7 +470,19 @@ function copieListeDeCarte(Liste) {
 	}
 	return copie;
 }
+function Verticale(coCarte) {
+	var laCarte;
+	laCarte = copieCarte(coCarte);
+	laCarte = laCarte.carteVerticale;
+	return laCarte;
+}
 
+function Horizontale(coCarte) {
+	var laCarte;
+	laCarte = copieCarte(coCarte);
+	laCarte = laCarte.carteHorizontale;
+	return laCarte;
+}
 
 
 function copieCarte(uneCarte) {
@@ -456,378 +490,145 @@ function copieCarte(uneCarte) {
 		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.SesFigures = new Array();
+	for (var i = 0; i < uneCarte.SesFigures.length; i++) {
+		carte.SesFigures.push(new Figure(uneCarte.SesFigures[i].type[0], uneCarte.SesFigures[i].getForme, uneCarte.SesFigures[i].getX, uneCarte.SesFigures[i].getY));
+		if (uneCarte.SesFigures[i].type.length > 1) {
+			for (var j = 1; j < uneCarte.SesFigures[i].type.length; j++) {
+				carte.SesFigures[carte.SesFigures.length - 1].type.push(uneCarte.SesFigures[i].type[j]);
+			}
+		}
+	}
 	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
-
+//FONCTION POUR TESTER L'ARBRE
 
+class CODE {
+	constructor(Carte) {
+		this.code = 0;
+		this.laCarte = Carte;
+	}
+}
 
-//================================================================================================================================
-//FONCTION COMPARAISON DE CARTE
-
-function comparaisonDeCarte(CarteMere, CarteFille) {
-	var Code = 0;
-	if (CarteMere == null) {
-		return 2;
-	}
-	var matCarteMere = CarteMere.getMatrice;
-	//CAS 1 : Il existe déja un ensemble( point <=> cercle ) sur CarteMere là où CarteFille possède un point ou un cercle
-	if ((matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 3) || (matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y] == 3)) {
-		//Impossible d'empiler
-		return 0;
-	}
-	//CAS 2 :  L'emplassement est parfait ! Les Coordonnées sont bonnes
-	if (matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 1) {
-		if (matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y] == 2) {
-			//Coordonnées parfaites
-			return 2;
+function AssemblageARBRE(TasDeCarte, Carte) {
+	var uneTable = copieListeDeCarte(TasDeCarte);
+	var tab = new Array();
+	var tabCode = new Array();
+	uneTable.splice(0, 1);
+	if (uneTable.length == 0) {
+		var leCode = new CODE(Carte);
+		tab.push(leCode);
+		return tab;
+	}
+	tab.push(AssemblageARBRE(uneTable, copieCarte(uneTable[0])));
+	tab.push(AssemblageARBRE(uneTable, Horizontale(uneTable[0])));
+	tab.push(AssemblageARBRE(uneTable, Verticale(uneTable[0])));
+	var derniereCarte = Horizontale(Verticale(uneTable[0]));
+	tab.push(AssemblageARBRE(uneTable, derniereCarte));
+	for (var i = 0; i < tab.length; i++) {
+		for (var j = 0; j < tab[i].length; j++) {
+			tabCode.push(tab[i][j]);
 		}
-
-	}
-	//CAS 3 : une seule liaison est possible
-	if ((matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 1) || (matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y] == 2)) {
-		return 1;
 	}
-	//Dernier cas : on ne peut rien faire avec ces cartes
-	return Code;
 
+	for (var i = 0; i < tabCode.length; i++) {
+		if (tabCode[i].code != -1) {
+			var enregistrement = tabCode[i].code;
+			tabCode[i] = comparaisonARBRE(tabCode[i].laCarte, Carte);
+			tabCode[i].code += enregistrement;
+		}
+	}
+	return tabCode;
 }
-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, CarteFilleEntree, index) {
-	/*matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 1
-	matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y]*/
+function comparaisonARBRE(CarteMereEntree, CarteFilleEntree) {
+	var retour = [];
+	var liaison = 0;
+	var CarteMere = copieCarte(CarteMereEntree);
 	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 
-	//les tester.
-
-	//On obtient ces opérations suivantes
-	if (index == 1) {
-		CarteFille = CarteFille.carteVerticale;
-	}
-	if (index == 2) {
-		CarteFille = CarteFille.carteHorizontale;
-	}
-	if (index == 3) {
-		CarteFille = CarteFille.carteVerticale;
-	}
-	if (index == 4) {
-		tabRetour.push(-1);
-		tabRetour.push(CarteMere);
-		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;
-	}
-	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);
-		if (Code2 == 2) {
-			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;
+	for (var i = 0; i < CarteFille.SesFigures.length; i++) {
+		for (var j = 0; j < CarteMere.SesFigures.length; j++) {
+			if (CarteFille.SesFigures[i].X == CarteMere.SesFigures[j].X) {
+				if (CarteFille.SesFigures[i].Y == CarteMere.SesFigures[j].Y) {
+					//Coordonnées identiques
+					if (CarteFille.SesFigures[i].forme == CarteMere.SesFigures[j].forme) {
+						//Forme identiques
+						for (var k = 0; k < CarteMere.SesFigures[j].type.length; k++) {
+							if (CarteFille.SesFigures[i].type[0] == TypeFigure.Petit) {
+								if (CarteMere.SesFigures[j].type[k] == TypeFigure.Petit) {
+									var leCode = new CODE(CarteMere);
+									leCode.code = -1;
+									return leCode;
+								}
+							} else if (CarteFille.SesFigures[i].type[0] == TypeFigure.Moyen) {
+								if (CarteMere.SesFigures[j].type[k] == TypeFigure.Moyen) {
+									var leCode = new CODE(CarteMere);
+									leCode.code = -1;
+									return leCode;
+								}
+							} else if (CarteFille.SesFigures[i].type[0] == TypeFigure.Grand) {
+								if (CarteMere.SesFigures[j].type[k] == TypeFigure.Grand) {
+									var leCode = new CODE(CarteMere);
+									leCode.code = -1;
+									return leCode;
+								}
+							}
+						}
+						//Si le type de la figure n'y est pas on l'ajoute à la liste de carte Mere;
+						liaison = liaison + 1;
+						CarteMere.SesFigures[j].type.push(CarteFille.SesFigures[i].type[0]);
+					} else {
+						var leCode = new CODE(CarteMere);
+						leCode.code = -1;
+						return leCode;
+					}
+				}
 			}
-			// 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);
-			tabRetour.push(CarteFille);
-			return tabRetour;
-		}
-
-		// On teste maintenant avec la variante verticalement symétrique
-
-		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;
-		}
-
-		if (Code2 == 1) {
-			// 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(3);
-			tabRetour.push(CarteFille);
-			return tabRetour;
 		}
-		CarteFille.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column);
-		tabRetour.push(Code1);
-		tabRetour.push(CarteFille);
-		return tabRetour;
 	}
-
-	tabRetour = comparaisonTotal(CarteMere, CarteFille, index + 1);
-	return tabRetour;
-
+	var CarteSomme = SommeDeCarte(CarteMere, copieCarte(CarteFille));
+	var leCode = new CODE(CarteSomme);
+	leCode.code = liaison;
+	return leCode;
 }
 
-//Assemblage
-
-function assemblage(carteselect, carteMereEntree) {
-	var Carte;
-	var carteMere = copieCarte(carteMereEntree);
-	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.length == 0) {
-		TabRetour.push(0);
-		TabRetour.push(carteMere);
-		return TabRetour;
-	}
-
-	else {
-		Carte = copieCarte(carteselect[0]);
-		CopieCarteMere = copieCarte(carteMere);
-		/*if (CopieCarteMere != null) {
-			window.alert("Copie Carte Mere faite\n" + CopieCarteMere.Matrice);
-        }*/
-		carteselect.shift();
-		TabComparaison = comparaisonTotalTest(carteMere, Carte, 0);
-	}
-
-	// 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;
-	}
-	// 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(Carte);
-		return assemblage(carteselect, CopieCarteMere);
-	}
-
-	if (TabComparaison[0] == 3) {
-		CarteParallele1 = copieCarte(TabComparaison[1]);
-		CarteParallele1.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele1.Matrice, CopieCarteMere.row, CopieCarteMere.column);
-		TabRetourAss = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele1));
-		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) {
-		window.alert(TabComparaison[1].Matrice)
-		CarteParallele1 = copieCarte(TabComparaison[1]);
-		CarteParallele1.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele1.Matrice, CopieCarteMere.row, CopieCarteMere.column);
-		TabRetourAss = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele1));
-
-		if (TabRetourAss[0] == 2) {
-			TabRetour.push(2);
-			TabRetour.push(TabRetourAss[1]);
-			return TabRetour;
+function SommeDeCarte(CarteMere, CarteFille) {
+	CarteMere.Matrice = creaMatriceVierge(CarteMere.row, CarteMere.column);
+	for (var i = 0; i < CarteFille.SesFigures.length; i++) {
+		var manquant = true;
+		for (var j = 0; j < CarteMere.SesFigures.length; j++) {
+			if (CarteFille.SesFigures[i].X == CarteMere.SesFigures[j].X) {
+				if (CarteFille.SesFigures[i].Y == CarteMere.SesFigures[j].Y) {
+					manquant = false;
+				}
+			}
 		}
-		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(TabRetourAss1[1]);
-			return TabRetour;
+		if (manquant) {
+			CarteMere.SesFigures.push(CarteFille.SesFigures[i]);
 		}
-		TabRetour.push(0);
-		TabRetour.push(TabRetourAss1[1]);
-		return TabRetour;
-	}
-	if (TabComparaison[0] == 1) {
-		return assemblage(copieListeDeCarte(carteselect), TabComparaison[1]);
 	}
 
+	for (var i = 0; i < CarteMere.SesFigures.length; i++) {
+		for (var j = 0; j < CarteMere.SesFigures[i].type.length; j++) {
+			if (CarteMere.SesFigures[i].type[j] == TypeFigure.Petit) {
+				CarteMere.Matrice[CarteMere.SesFigures[i].X][CarteMere.SesFigures[i].Y] += 1;
+			} else if (CarteMere.SesFigures[i].type[j] == TypeFigure.Moyen) {
+				CarteMere.Matrice[CarteMere.SesFigures[i].X][CarteMere.SesFigures[i].Y] += 2;
+			} else if (CarteMere.SesFigures[i].type[j] == TypeFigure.Grand) {
+				CarteMere.Matrice[CarteMere.SesFigures[i].X][CarteMere.SesFigures[i].Y] += 4;
+			}
+		}
+	}
+	return CarteMere;
 }
 
+//================================================================================================================================
+
 //==================================================================================