pascal.lafourcade
/
swish
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Nouveau traitement des cartes en ARBRE git status!

Browse Source
Golfier
Yannis 4 years ago
parent 16de391d91
commit 9ab3b3ce4a
1 changed files with 199 additions and 398 deletions
Show Stats Download Patch File Download Diff File

575
SwichGIT/src/js/main.js
Unescape View File

@ -18,6 +18,7 @@ class Carte {
this.row = 4 /*row*/; this.row = 4 /*row*/;
this.column = 3 /*column*/; this.column = 3 /*column*/;
this.Matrice = creaMatrice(this.row, this.column); this.Matrice = creaMatrice(this.row, this.column);
this.SesFigures = [];
//lien clicable //lien clicable
this.link = document.createElement('a'); this.link = document.createElement('a');
@ -37,8 +38,8 @@ class Carte {
if (this.Matrice[i % 3][Math.floor(i / 3)] == 1) { if (this.Matrice[i % 3][Math.floor(i / 3)] == 1) {
//TEST : CRéation d'une figure Pleine => Rond //TEST : CRéation d'une figure Pleine => Rond
var uneFigure = new Figure(TypeFigure.Pleine, FormeFigure.Rond, i % 3, Math.floor(i / 3)); var uneFigure = new Figure(TypeFigure.Petit, FormeFigure.Rond, i % 3, Math.floor(i / 3));
this.FigPleine = uneFigure; this.SesFigures.push(uneFigure);
divconteneur.appendChild(uneFigure.getHTML); divconteneur.appendChild(uneFigure.getHTML);
@ -47,10 +48,10 @@ class Carte {
//TEST : CRéation d'une figure Pleine => Anneau //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); divconteneur.appendChild(uneFigure.getHTML);
@ -86,42 +87,47 @@ class Carte {
get carteVerticale() { get carteVerticale() {
// Copie de la Carte d'origine for (var i = 0; i < this.SesFigures.length; i++) {
var carteVerticale = this; this.SesFigures[i].X = this.column - this.SesFigures[i].X - 1;
}
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); this.Matrice = creaMatriceVierge(this.row, this.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;
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() { get carteHorizontale() {
//Copie de la carte d'origine for (var i = 0; i < this.SesFigures.length; i++) {
var carteHorizontale = this; this.SesFigures[i].Y = this.row - this.SesFigures[i].Y - 1;
}
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
carteHorizontale.Matrice = creaMatriceVierge(carteHorizontale.row, carteHorizontale.column); this.Matrice = creaMatriceVierge(this.row, this.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;
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() { get getHTML() {
@ -136,30 +142,27 @@ class Carte {
return this.Matrice; return this.Matrice;
} }
get getFigurePleine() { get getSesFigures() {
return this.FigPleine; return this.SesFigures;
}
get getFigureCreuse() {
return this.FigCreuse;
} }
} }
class Figure { class Figure {
constructor(type, forme, Cox, Coy) { constructor(leType, forme, Cox, Coy) {
this.X = Cox; this.X = Cox;
this.Y = Coy; this.Y = Coy;
this.type = type; this.type = [];
this.type.push(leType);
this.forme = forme; this.forme = forme;
var pos = this.X + this.Y * 3; var pos = this.X + this.Y * 3;
var divcase = document.createElement('div'); var divcase = document.createElement('div');
divcase.className = "item-form"; divcase.className = "item-form";
switch (this.forme) { switch (this.forme) {
case FormeFigure.Rond: case FormeFigure.Rond:
switch (this.type) { switch (this.type[0]) {
case TypeFigure.Creuse: case TypeFigure.Moyen:
var divContainForm = document.createElement('div'); var divContainForm = document.createElement('div');
divContainForm.className = "containform"; divContainForm.className = "containform";
@ -186,7 +189,7 @@ class Figure {
this.CodeHTML = divcase; this.CodeHTML = divcase;
break; break;
case TypeFigure.Pleine: case TypeFigure.Petit:
var divContainForm = document.createElement('div'); var divContainForm = document.createElement('div');
divContainForm.className = "containform"; divContainForm.className = "containform";
@ -239,8 +242,9 @@ const FormeFigure = {
}; };
const TypeFigure = { const TypeFigure = {
Pleine: 'pleine', Petit: 'petit',
Creuse: 'creuse' Moyen: 'moyen',
Grand: 'grand'
}; };
@ -325,7 +329,7 @@ function creePartie() {
while (document.getElementById("containcards").firstElementChild != null) { while (document.getElementById("containcards").firstElementChild != null) {
document.getElementById("containcards").firstElementChild.remove(); document.getElementById("containcards").firstElementChild.remove();
} }
for (var j = 1; j <= 16; j++) { for (var j = 1; j <= 32; j++) {
var uneCarte = new Carte(j); var uneCarte = new Carte(j);
@ -427,20 +431,38 @@ function test() {
for (var i = 0; i < carteselect.length; i++) { for (var i = 0; i < carteselect.length; i++) {
copie.push(carteselect[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 uneTable = copieListeDeCarte(copie);
*/ uneTable.splice(0, 1);
var tab = assemblage(copie, null); var TEST = AssemblageARBRE(uneTable, copie[0]);
window.alert("Code Final " + tab[0]); changerlesCartes();*/
if (tab[0] == 2) { 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(); changerlesCartes();
} }
}
if (solution) {
window.alert("Rien trouvé chef !!!");
}
if (!solution) {
window.alert("J'ai une solution chef !!!!");
}
} }
} catch (e) { } catch (e) {
window.alert("Assemblage Impossible"); window.alert("Assemblage Impossible");
} }
} }
function copieListeDeCarte(Liste) { function copieListeDeCarte(Liste) {
var copie = []; var copie = [];
for (var i = 0; i < Liste.length; i++) { for (var i = 0; i < Liste.length; i++) {
@ -448,7 +470,19 @@ function copieListeDeCarte(Liste) {
} }
return copie; 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) { function copieCarte(uneCarte) {
@ -456,378 +490,145 @@ function copieCarte(uneCarte) {
return null; return null;
} }
var carte = new Carte(uneCarte.getIdentifiant); var carte = new Carte(uneCarte.getIdentifiant);
carte.FigCreuse.forme = uneCarte.FigCreuse.forme; carte.SesFigures = new Array();
carte.FigPleine.forme = uneCarte.FigPleine.forme; for (var i = 0; i < uneCarte.SesFigures.length; i++) {
carte.FigCreuse.type = uneCarte.FigCreuse.type; carte.SesFigures.push(new Figure(uneCarte.SesFigures[i].type[0], uneCarte.SesFigures[i].getForme, uneCarte.SesFigures[i].getX, uneCarte.SesFigures[i].getY));
carte.FigPleine.type = uneCarte.FigPleine.type; if (uneCarte.SesFigures[i].type.length > 1) {
carte.FigCreuse.X = uneCarte.FigCreuse.X; for (var j = 1; j < uneCarte.SesFigures[i].type.length; j++) {
carte.FigPleine.X = uneCarte.FigPleine.X; carte.SesFigures[carte.SesFigures.length - 1].type.push(uneCarte.SesFigures[i].type[j]);
carte.FigCreuse.Y = uneCarte.FigCreuse.Y; }
carte.FigPleine.Y = uneCarte.FigPleine.Y; }
}
carte.Matrice = copieMatrice(uneCarte.Matrice, uneCarte.row, uneCarte.column); carte.Matrice = copieMatrice(uneCarte.Matrice, uneCarte.row, uneCarte.column);
return carte; 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;
}
}
//================================================================================================================================ function AssemblageARBRE(TasDeCarte, Carte) {
//FONCTION COMPARAISON DE CARTE var uneTable = copieListeDeCarte(TasDeCarte);
var tab = new Array();
function comparaisonDeCarte(CarteMere, CarteFille) { var tabCode = new Array();
var Code = 0; uneTable.splice(0, 1);
if (CarteMere == null) { if (uneTable.length == 0) {
return 2; var leCode = new CODE(Carte);
tab.push(leCode);
return tab;
} }
var matCarteMere = CarteMere.getMatrice; tab.push(AssemblageARBRE(uneTable, copieCarte(uneTable[0])));
//CAS 1 : Il existe déja un ensemble( point <=> cercle ) sur CarteMere là où CarteFille possède un point ou un cercle tab.push(AssemblageARBRE(uneTable, Horizontale(uneTable[0])));
if ((matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 3) || (matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y] == 3)) { tab.push(AssemblageARBRE(uneTable, Verticale(uneTable[0])));
//Impossible d'empiler var derniereCarte = Horizontale(Verticale(uneTable[0]));
return 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 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;
} }
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;
} }
//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 tabCode;
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 comparaisonARBRE(CarteMereEntree, CarteFilleEntree) {
var retour = [];
function comparaisonTotal(CarteMere, CarteFilleEntree, index) { var liaison = 0;
/*matCarteMere[CarteFille.FigCreuse.X][CarteFille.FigCreuse.Y] == 1 var CarteMere = copieCarte(CarteMereEntree);
matCarteMere[CarteFille.FigPleine.X][CarteFille.FigPleine.Y]*/
var CarteFille = copieCarte(CarteFilleEntree); var CarteFille = copieCarte(CarteFilleEntree);
var Code1 = 0; for (var i = 0; i < CarteFille.SesFigures.length; i++) {
var Code2 = 0; for (var j = 0; j < CarteMere.SesFigures.length; j++) {
var tabRetour = []; if (CarteFille.SesFigures[i].X == CarteMere.SesFigures[j].X) {
if (CarteFille.SesFigures[i].Y == CarteMere.SesFigures[j].Y) {
if (CarteMere == null) { //Coordonnées identiques
tabRetour.push(1); if (CarteFille.SesFigures[i].forme == CarteMere.SesFigures[j].forme) {
tabRetour.push(CarteFille); //Forme identiques
return tabRetour; 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) {
// NOTE : Cette fonction sait combien de fois elle a été appelée grâce à la variable index. var leCode = new CODE(CarteMere);
//En effet pour une carte donnée il existe 4 variantes d'elle-même. leCode.code = -1;
//La fonction va donc appeler au fur et à mesure toutes ses variantes et return leCode;
//les tester. }
} else if (CarteFille.SesFigures[i].type[0] == TypeFigure.Moyen) {
//On obtient ces opérations suivantes if (CarteMere.SesFigures[j].type[k] == TypeFigure.Moyen) {
if (index == 1) { var leCode = new CODE(CarteMere);
CarteFille = CarteFille.carteVerticale; leCode.code = -1;
} return leCode;
if (index == 2) { }
CarteFille = CarteFille.carteHorizontale; } else if (CarteFille.SesFigures[i].type[0] == TypeFigure.Grand) {
} if (CarteMere.SesFigures[j].type[k] == TypeFigure.Grand) {
if (index == 3) { var leCode = new CODE(CarteMere);
CarteFille = CarteFille.carteVerticale; leCode.code = -1;
} return leCode;
if (index == 4) { }
tabRetour.push(-1); }
tabRetour.push(CarteMere); }
return tabRetour; //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]);
Code1 = comparaisonDeCarte(CarteMere, CarteFille); } else {
var leCode = new CODE(CarteMere);
if (Code1 == 2) { leCode.code = -1;
CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column); return leCode;
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;
} }
// 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); var CarteSomme = SommeDeCarte(CarteMere, copieCarte(CarteFille));
tabRetour.push(Code1); var leCode = new CODE(CarteSomme);
tabRetour.push(CarteFille); leCode.code = liaison;
return tabRetour; return leCode;
}
tabRetour = comparaisonTotal(CarteMere, CarteFille, index + 1);
return tabRetour;
} }
//Assemblage function SommeDeCarte(CarteMere, CarteFille) {
CarteMere.Matrice = creaMatriceVierge(CarteMere.row, CarteMere.column);
function assemblage(carteselect, carteMereEntree) { for (var i = 0; i < CarteFille.SesFigures.length; i++) {
var Carte; var manquant = true;
var carteMere = copieCarte(carteMereEntree); for (var j = 0; j < CarteMere.SesFigures.length; j++) {
var CopieCarteMere; if (CarteFille.SesFigures[i].X == CarteMere.SesFigures[j].X) {
var CarteParallele1; if (CarteFille.SesFigures[i].Y == CarteMere.SesFigures[j].Y) {
var CarteParallele2; manquant = false;
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 if (manquant) {
//correctement le tas de carte.On le signal CarteMere.SesFigures.push(CarteFille.SesFigures[i]);
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) { for (var i = 0; i < CarteMere.SesFigures.length; i++) {
CarteParallele1 = copieCarte(TabComparaison[1]); for (var j = 0; j < CarteMere.SesFigures[i].type.length; j++) {
CarteParallele1.Matrice = somMatrice(CopieCarteMere.Matrice, CarteParallele1.Matrice, CopieCarteMere.row, CopieCarteMere.column); if (CarteMere.SesFigures[i].type[j] == TypeFigure.Petit) {
TabRetourAss = assemblage(copieListeDeCarte(carteselect), copieCarte(CarteParallele1)); CarteMere.Matrice[CarteMere.SesFigures[i].X][CarteMere.SesFigures[i].Y] += 1;
if (TabRetourAss[0] == 2) { } else if (CarteMere.SesFigures[i].type[j] == TypeFigure.Moyen) {
TabRetour.push(2); CarteMere.Matrice[CarteMere.SesFigures[i].X][CarteMere.SesFigures[i].Y] += 2;
TabRetour.push(TabRetourAss[1]); } else if (CarteMere.SesFigures[i].type[j] == TypeFigure.Grand) {
return TabRetour; CarteMere.Matrice[CarteMere.SesFigures[i].X][CarteMere.SesFigures[i].Y] += 4;
} }
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;
} }
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;
} }
TabRetour.push(0); return CarteMere;
TabRetour.push(TabRetourAss1[1]);
return TabRetour;
}
if (TabComparaison[0] == 1) {
return assemblage(copieListeDeCarte(carteselect), TabComparaison[1]);
}
} }
//================================================================================================================================
//================================================================================== //==================================================================================

Write Preview
Loading…
Cancel
Save