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

Ajout de la derniere fonction de Empiler 3/3

Browse Source
Golfier
Yannis 4 years ago
parent c1453b3412
commit c7d93fe16b
2 changed files with 246 additions and 50 deletions
Show Stats Download Patch File Download Diff File

1
SwichGIT/src/debug.log
Unescape View File

@ -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)

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

@ -352,16 +352,27 @@ function remplacerLaCarte(uneCarte) {
//====================================================================================
//GESTION DE MATRICE
function somMatrice(matrice1, matrice2) {
var somMatrice = creaMatriceVierge(matrice1.length, matrice1[0].length);
for (var i = 0; i < matrice1.length; i++) {
for (var j = 0; j < matrice1[i].length; j++) {
function somMatrice(matrice1, matrice2, row, column) {
var somMatrice = creaMatriceVierge(row, column);
for (var i = 0; i < column; i++) {
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);
window.alert(tab[0])
window.alert(tab[1].getMatrice)
var copie = [];
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]);
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, CarteFille.carteHorizontale);
Code2 = comparaisonDeCarte(CarteMere, copieCarte(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;
CarteMere.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice);
CarteFille.Matrice = somMatrice(CarteMere.Matrice, CarteFille.Matrice, CarteMere.row, CarteMere.column);
tabRetour.push(Code1);
tabRetour.push(CarteMere);
tabRetour.push(CarteFille);
return tabRetour;
}
@ -551,81 +715,112 @@ function comparaisonTotal(CarteMere, CarteFille, index) {
//Assemblage
function assemblage(carteselect, carteMere) {
function assemblage(carteselect, carteMereEntree) {
var Carte;
var CopieCarteMere = carteMere;;
var CarteParallele;
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 != null) {
if (carteselect.length == 0) {
TabRetour.push(0);
TabRetour.push(carteMere);
return TabRetour;
}
else {
Carte = carteselect[0];
CopieCarteMere = carteMere;
TabComparaison = comparaisonTotal(carteMere, Carte, 0);
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);
}
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;
//pb tabRetour ?
TabRetourAss = assemblage(carteselect, CopieCarteMere + CarteParallele);
TabRetourAss1 = assemblage(carteselect, CopieCarteMere + CarteParallele.carteVerticale);
if (TabRetourAss1[0] == 2) {
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(TabRetourAss1[1]);
TabRetour.push(TabRetourAss[1]);
return TabRetour;
}
if (TabRetourAss[0] == 2) {
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(TabRetourAss[1]);
TabRetour.push(TabRetourAss1[1]);
return TabRetour;
}
TabRetour.push(2);
//pb tabRetour ?
TabRetour.push(0);
TabRetour.push(carteMere);
return TabRetour;
}
if (TabComparaison[0] == 4) {
CarteParallele = carteMere;
TabRetourAss = assemblage(carteselect, CopieCarteMere + CarteParallele);
TabRetourAss1 = assemblage(carteselect, CopieCarteMere + CarteParallele.carteHorizontale);
if (TabRetourAss1[0] == 2) {
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(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]);
}
}

Write Preview
Loading…
Cancel
Save