You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
893 lines
26 KiB
893 lines
26 KiB
var mode = 1;
|
|
var nbplayers = 1;
|
|
var lightprima = "#DEDEDE";
|
|
var lightsedonca = "#B7B7B7";
|
|
var lighttercia = "#E6E6E6";
|
|
|
|
var darkprima = "#474747";
|
|
var darkseconda = "#393939";
|
|
var darktercia = "#606060";
|
|
var carteselect = [];
|
|
var deckPartie = []; //Ensemble des cartes affichées à l'écran
|
|
|
|
class Carte {
|
|
|
|
constructor(id/*,row,column,nbForme*/) { //à décommenter quand il y aura des prametres de partie
|
|
//Attribut de Classe
|
|
this.identifiant = id;
|
|
this.row = 4 /*row*/;
|
|
this.column = 3 /*column*/;
|
|
this.Matrice = creaMatrice(this.row, this.column);
|
|
|
|
//lien clicable
|
|
this.link = document.createElement('a');
|
|
this.link.id = this.identifiant;
|
|
|
|
//div carte
|
|
var divconteneur = document.createElement('div');
|
|
divconteneur.className = "flex-item";
|
|
divconteneur.id = "card" + this.identifiant;
|
|
|
|
for (var i = 0; i < 12; i++) {
|
|
|
|
var divcase = document.createElement('div');
|
|
divcase.className = "item-form";
|
|
|
|
// Point ou anneau trouvé => création
|
|
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;
|
|
|
|
divconteneur.appendChild(uneFigure.getHTML);
|
|
|
|
|
|
} else if (this.Matrice[i % 3][Math.floor(i / 3)] == 2) { // Point ou anneau trouvé => création
|
|
|
|
//TEST : CRéation d'une figure Pleine => Anneau
|
|
|
|
var uneFigure = new Figure(TypeFigure.Creuse, FormeFigure.Rond, i % 3, Math.floor(i / 3));
|
|
|
|
|
|
this.FigCreuse = uneFigure;
|
|
|
|
divconteneur.appendChild(uneFigure.getHTML);
|
|
|
|
} else divconteneur.appendChild(divcase);
|
|
|
|
}
|
|
|
|
this.link.appendChild(divconteneur);
|
|
//fonction de selection
|
|
this.link.onclick = function selectioncarte() {
|
|
var macarte = this.id;
|
|
var lacarte = "card" + macarte;
|
|
|
|
var laCarte = deckPartie[this.id - 1]; //Carte liée avec le code HTML
|
|
|
|
if (document.getElementById(lacarte).style.boxShadow != "") {
|
|
var pos = carteselect.indexOf(laCarte);
|
|
carteselect.splice(pos, 1);
|
|
document.getElementById(lacarte).style.boxShadow = "";
|
|
}
|
|
else {
|
|
if (carteselect.length < 5) {
|
|
carteselect.push(laCarte);
|
|
document.getElementById(lacarte).style.boxShadow = "0 0 1vw red, 0 0 1vw red";
|
|
}
|
|
else
|
|
window.alert("Bonjour !");
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
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;
|
|
}
|
|
|
|
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
|
|
|
|
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;
|
|
|
|
return carteHorizontale;
|
|
}
|
|
|
|
get getHTML() {
|
|
return this.link;
|
|
}
|
|
|
|
get getIdentifiant() {
|
|
return this.identifiant;
|
|
}
|
|
|
|
get getMatrice() {
|
|
return this.Matrice;
|
|
}
|
|
|
|
get getFigurePleine() {
|
|
return this.FigPleine;
|
|
}
|
|
|
|
get getFigureCreuse() {
|
|
return this.FigCreuse;
|
|
}
|
|
}
|
|
|
|
class Figure {
|
|
|
|
constructor(type, forme, Cox, Coy) {
|
|
this.X = Cox;
|
|
this.Y = Coy;
|
|
this.type = type;
|
|
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) {
|
|
|
|
case TypeFigure.Creuse:
|
|
|
|
var divContainForm = document.createElement('div');
|
|
divContainForm.className = "containform";
|
|
|
|
var unCercle = document.createElement('div');
|
|
unCercle.className = "anneau";
|
|
|
|
if (pos == 0 || pos == 2 || pos == 9 || pos == 11) {
|
|
unCercle.style.backgroundColor = "#00CBFF";
|
|
}
|
|
if (pos == 1 || pos == 10) {
|
|
unCercle.style.backgroundColor = "#00FF6E";
|
|
}
|
|
if (pos == 4 || pos == 7) {
|
|
unCercle.style.backgroundColor = "#C800FF";
|
|
}
|
|
|
|
var unRond = document.createElement('div');
|
|
unRond.className = "rondinterieur inté";
|
|
|
|
unCercle.appendChild(unRond);
|
|
divContainForm.appendChild(unCercle);
|
|
divcase.appendChild(divContainForm);
|
|
this.CodeHTML = divcase;
|
|
break;
|
|
|
|
case TypeFigure.Pleine:
|
|
|
|
var divContainForm = document.createElement('div');
|
|
divContainForm.className = "containform";
|
|
|
|
var unRond = document.createElement('div');
|
|
unRond.className = "rond";
|
|
//unRond.style.backgroundColor = "#000DFF";
|
|
if (pos == 0 || pos == 2 || pos == 9 || pos == 11) {
|
|
unRond.style.backgroundColor = "#00CBFF";
|
|
}
|
|
if (pos == 1 || pos == 10) {
|
|
unRond.style.backgroundColor = "#00FF6E";
|
|
}
|
|
if (pos == 4 || pos == 7) {
|
|
unRond.style.backgroundColor = "#C800FF";
|
|
}
|
|
divContainForm.appendChild(unRond);
|
|
divcase.appendChild(divContainForm);
|
|
this.CodeHTML = divcase;
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
get getHTML() {
|
|
return this.CodeHTML;
|
|
}
|
|
get getX() {
|
|
return this.X;
|
|
}
|
|
get getY() {
|
|
return this.Y;
|
|
}
|
|
get getType() {
|
|
return this.type;
|
|
}
|
|
get getForme() {
|
|
return this.forme;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
const FormeFigure = {
|
|
Rond: 'rond',
|
|
Carre: 'carre',
|
|
Triangle: 'triangle',
|
|
Pentagone: 'pentagone',
|
|
Losange: 'Losange'
|
|
};
|
|
|
|
const TypeFigure = {
|
|
Pleine: 'pleine',
|
|
Creuse: 'creuse'
|
|
};
|
|
|
|
|
|
function journuit() {
|
|
//mode jour
|
|
if (mode % 2 == 0) {
|
|
//changer logo swish
|
|
document.getElementById("imglogo").src = "imgs/swishjour.png";
|
|
document.getElementById("imglogo2").src = "imgs/swishjour.png";
|
|
/*
|
|
MESSAGE POUR CEUX QUI FONT LES TESTS ! Recommentez les lignes après ! Merci
|
|
*/
|
|
//document.getElementById("fondinput").style.backgroundColor = lightsedonca;
|
|
document.getElementById("contourbuttonvalider").style.backgroundColor = lightsedonca;
|
|
//document.getElementById("textjouer").style.color = lightsedonca;
|
|
//document.getElementById("textplus").style.color = lightprima;
|
|
//changer montagnesfond
|
|
document.getElementById("mount1").src = "imgs/mount1.png";
|
|
document.getElementById("mount2").src = "imgs/mount2.png";
|
|
//nuages
|
|
document.getElementById("cloud").src = "imgs/lightcloud.png";
|
|
//changer background color
|
|
//document.getElementById("containplayers").style.color = lightsedonca;
|
|
//maj couleur principales
|
|
document.documentElement.style.setProperty('--lightprima', lightprima);
|
|
document.documentElement.style.setProperty('--lightsedonca', lightsedonca);
|
|
document.documentElement.style.setProperty('--lighttercia', lighttercia);
|
|
}
|
|
//mode nuit
|
|
else {
|
|
//changer logo swish
|
|
document.getElementById("imglogo").src = "imgs/swishnuit.png";
|
|
document.getElementById("imglogo2").src = "imgs/swishnuit.png";
|
|
|
|
//document.getElementById("fondinput").style.backgroundColor = darkseconda;
|
|
document.getElementById("contourbuttonvalider").style.backgroundColor = darkseconda;
|
|
//document.getElementById("textjouer").style.color = darkseconda;
|
|
//document.getElementById("textplus").style.color = darkprima;
|
|
//changer montagnesfond
|
|
document.getElementById("mount1").src = "imgs/darkmount1.png";
|
|
document.getElementById("mount2").src = "imgs/darkmount2.png";
|
|
//nuages
|
|
document.getElementById("cloud").src = "imgs/darkcloud.png";
|
|
//mode nuit
|
|
//document.getElementById("containplayers").style.color = darkseconda;
|
|
//maj couleur principales
|
|
document.documentElement.style.setProperty('--lightprima', darkprima);
|
|
document.documentElement.style.setProperty('--lightsedonca', darkseconda);
|
|
document.documentElement.style.setProperty('--lighttercia', darktercia);
|
|
}
|
|
mode = mode + 1;
|
|
}
|
|
|
|
//===================================================================================
|
|
//FONCTION GESTION DE GAME
|
|
|
|
function lancerpartie() {
|
|
document.getElementById("pageAccueil").style.visibility = "hidden";
|
|
creePartie();
|
|
document.getElementById("pageGame").style.visibility = "visible";
|
|
}
|
|
|
|
function retour() {
|
|
document.getElementById("pageAccueil").style.visibility = "visible";
|
|
document.getElementById("pageGame").style.visibility = "hidden";
|
|
}
|
|
|
|
function rechargerGAME() {
|
|
while (document.getElementById("containcards").firstElementChild != null) {
|
|
document.getElementById("containcards").firstElementChild.remove();
|
|
}
|
|
for (var i = 0; i < deckPartie.length; i++) {
|
|
document.getElementById("containcards").appendChild(deckPartie[i].getHTML);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
function creePartie() {
|
|
deckPartie = [];
|
|
carteselect = [];
|
|
while (document.getElementById("containcards").firstElementChild != null) {
|
|
document.getElementById("containcards").firstElementChild.remove();
|
|
}
|
|
for (var j = 1; j <= 16; j++) {
|
|
|
|
var uneCarte = new Carte(j);
|
|
|
|
deckPartie.push(uneCarte);
|
|
|
|
document.getElementById("containcards").appendChild(uneCarte.getHTML);
|
|
}
|
|
}
|
|
|
|
function changerlesCartes() {
|
|
while (carteselect.length != 0) {
|
|
remplacerLaCarte(carteselect[0]);
|
|
carteselect.shift();
|
|
}
|
|
rechargerGAME();
|
|
}
|
|
|
|
function remplacerLaCarte(uneCarte) {
|
|
pos = deckPartie.indexOf(uneCarte);
|
|
var newCarte = new Carte(pos + 1);
|
|
deckPartie[pos] = newCarte;
|
|
}
|
|
|
|
//====================================================================================
|
|
//GESTION DE MATRICE
|
|
|
|
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)
|
|
}
|
|
|
|
function creaMatriceVierge(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] = 0;
|
|
}
|
|
}
|
|
return myMatrice;
|
|
}
|
|
|
|
function creaMatrice(row, column) {
|
|
|
|
var myMatrice = creaMatriceVierge(row, column);
|
|
|
|
var Cox1, Coy1, Cox2, Coy2;
|
|
|
|
Cox1 = getRandom(0, 2);
|
|
Coy1 = getRandom(0, 3);
|
|
|
|
myMatrice[Cox1][Coy1] = 1;
|
|
|
|
Cox2 = getRandom(0, 2);
|
|
Coy2 = getRandom(0, 3);
|
|
|
|
while (Cox2 == Cox1 && Coy1 == Coy2) {
|
|
Cox2 = getRandom(0, 2);
|
|
Coy2 = getRandom(0, 3);
|
|
}
|
|
myMatrice[Cox2][Coy2] = 2;
|
|
|
|
return myMatrice;
|
|
|
|
}
|
|
//=================================================================================
|
|
//FONCTION DE TEST => permet de tester des fonctionnalité via le bouton VALIDER
|
|
|
|
function test() {
|
|
try {
|
|
if (carteselect.length == 0) {
|
|
window.alert("Selection Vide");
|
|
return;
|
|
} else if (carteselect.length < 2) {
|
|
window.alert("Selection Trop Petite");
|
|
return;
|
|
} else {
|
|
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]);
|
|
if (tab[0] == 2) {
|
|
changerlesCartes();
|
|
}
|
|
|
|
}
|
|
} catch (e) {
|
|
window.alert("Assemblage Impossible");
|
|
}
|
|
}
|
|
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
|
|
|
|
|
|
|
|
//================================================================================================================================
|
|
//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;
|
|
}
|
|
|
|
}
|
|
//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;
|
|
|
|
}
|
|
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]*/
|
|
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;
|
|
}
|
|
// 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;
|
|
|
|
}
|
|
|
|
//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;
|
|
}
|
|
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);
|
|
TabRetour.push(TabRetourAss1[1]);
|
|
return TabRetour;
|
|
}
|
|
if (TabComparaison[0] == 1) {
|
|
return assemblage(copieListeDeCarte(carteselect), TabComparaison[1]);
|
|
}
|
|
|
|
}
|
|
|
|
//==================================================================================
|
|
|
|
|
|
|
|
function ChoisirPseudo() {
|
|
let nom = localStorage.getItem('nom');
|
|
if (nom == null) {
|
|
nom = "SWISH";
|
|
}
|
|
document.getElementById('inputpseudo').setAttribute('value', nom);
|
|
};
|
|
|
|
function EnvoyerNouveauNom() {
|
|
|
|
let pseudo = document.getElementById('inputpseudo').value;
|
|
localStorage.setItem('nom', pseudo);
|
|
document.location.reload(true);
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
function addplayer(){
|
|
//j'ai mis une limite de 6joueurs, mais c'est à voir
|
|
if(nbplayers < 7){
|
|
//création de la div contenant le pseudo
|
|
var divpseudo = document.createElement('div');
|
|
divpseudo.id = 'pseudolist';
|
|
//reprise du pseudo entré par le joueur
|
|
var pseudo = document.getElementById("inputpseudo").value;
|
|
//vérification si pseudo vide pour lui donner un pseudo du style "Joueur3"
|
|
if(pseudo == "")
|
|
{
|
|
pseudo = "Joueur " + nbplayers;
|
|
}
|
|
//création du text-pseudo
|
|
var tag = document.createElement("p");
|
|
tag.className = "pseudojoueur";
|
|
var text = document.createTextNode(pseudo);
|
|
tag.appendChild(text);
|
|
//mise du text dans la division
|
|
divpseudo.appendChild(tag);
|
|
//insertion pseudo dans liste
|
|
document.getElementById("containplayers").appendChild(divpseudo);
|
|
//remise input vide ;)
|
|
document.getElementById("inputpseudo").value = "";
|
|
nbplayers = nbplayers +1;
|
|
}
|
|
}
|
|
|
|
function ajouterplayer(event){
|
|
if(event.keyCode == 13)
|
|
addplayer();
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|