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

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

@ -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;
}
//================================================================================================================================
//==================================================================================

Write Preview
Loading…
Cancel
Save