Ajout Doc recherche intelligente + implémentation de la recherche intelligente

SwichGIT/Doc/Algorithme/Fonction_Recherche_Intelligente.md

@@ -0,0 +1,193 @@
+# RECHERCHE DE SWISH INTELLIGENTE#
+
+Ce document, présente une version de l'algorithme de recherche utilisé dans notre projet. Il a pour objectif d'énumérer tous les Swish possibles de 2, 3, 4, ou 5 cartes sur un plateau de jeu présentées à un joueur. Il pourra également être utilisé pour aider les joueurs si aucun Swish n'est possible et ainsi débloquer le jeu ou arrêter la partie.
+
+## DEFINITION DES STRUCTURES ##
+
+### ENSEMBLE ###
+### Attributs ###
+//Permet de déterminer si un ensemble de carte peut **théoriquement** former un Swish en regardant uniquement la couleur de leurs **Figures**
+
+- **ensemble** //Liste d'entier représentant les index des cartes dans le plateau de jeu
+- **v** //Entier notifiant si l'ensemble d'index peut **théoriquement** former un Swish
+
+---
+
+## DEFINITION DES FONCTIONS UTILISEE POUR CETTE RECHERCHE ##
+
+# SOMME CARRE ELEMENT #
+
+**Objectif** : Calculer la somme des puissances de 2 d'une liste d'entier envoyé en paramètre.
+
+**sommeCarreElement(liste: int[])** : Int
+
+**Entrées** :
+
+	-**liste** : liste d'entier
+
+**Sortie** : 
+
+	-**int** : Somme des puissances de 2 de l'ensemble
+
+### COMMENT FAIRE ###
+
+- Pour chaque entier présent dans la liste envoyé en parametre
+
+	- Mettre 2 à la puissance de l'entier présent à cet index et faire une somme.
+
+Une fois la somme calculée, on retourne le résultat.
+
+---
+
+# COMPARAISON EMPILEMENT #
+
+**Objectif** : Enlever les doublons d'une liste envoyée en paramètre.
+
+**Pourquoi cette fonction ?** : Notre recherche intelligente est capable de trouver tout les SWISH possibles sur un plateau de jeu mais également TOUTES les façons de les obtenir. Pour des SWISH à 4 ou 5 cartes, le temps de recherche est fortement allongé du fait que pour un SWISH avec un tas composé de n **Cartes"**, il existe 4^n variantes de ce même tas.
+
+Calculer plusieurs fois le même tas différements mélangé fais perdre beaucoup de temps. Cette fonction va donc, en calculant ces sommes, enlever les doublons et gagner du temps pour le confort de l'utilisateur.
+
+**comparaisonEmpilement(liste: Ensemble[], debut: int)** : int[]
+
+**Entrées** :
+
+	-liste** : Liste d'Ensemble, contient tout les ensembles qui peuvent **théoriquement** former un Swish.
+
+	- debut** : entier permettant de savoir à quel index ded la liste nous sommes
+
+**Sortie** : 
+
+	-**Ensemble[]** : Nouvelle liste d'ensemble ne contenant plus de doublon **d'Ensemble**
+
+### COMMENT FAIRE ###
+
+-Si début est supérieur ou égal à l'index du dernier élément de la liste cela signifie que l'algorithme possède une liste sans doublon et a terminé ses opérations. On retourne donc la liste actuelle.
+
+-On récupère tout les éléments de la liste de 0 jusqu'à l'index **début** qui ne sont pas en doublon.
+
+-On calcule la **sommeCarreElement** de l'élément présent à l'index **début** de la liste pour l'identifier.
+
+-Une fois cette somme récupérée, on la compare avec la **sommeCarreElement** de tous les éléments de la liste restant 
+
+-Si les **sommeCarreElement** sont différent on récupère l'élément à cet index
+-Une fois les doublons de l'élément à l'index **début** retiré, on appelle récursivement cette fonction **comparaisonEmpilement()** avec pour paramètre la liste mis à jour et début incrémenté.
+
+---
+
+# RECHERCHE CARTE COMPLEMENTAIRE #
+
+-**Objectif**: Rechercher toutes les cartes du plateau de jeu contenant une figure complémentaire (type différent et couleur identique) avec la figure envoyée en paramètre.
+
+
+**carteComplementaire**(figure: Figure, debut: int): int[]
+
+**Entrées** :
+
+	-**figure**: Structure **Figure** depuis laquelle nous allons rechercher toutes les cartes avec une **Figure** complémentaire.
+
+	-**debut** : Entier permettant de notifier où l'on se trouve dans le plateau de jeu dans le but de ne pas créer de boucle dans les recherches.
+
+**Sortie**
+
+	-**int[]** : Liste d'entier contenant les index des cartes comportant une **Figure** complémentaire dans le plateau de jeu.
+
+### COMMENT FAIRE ###
+
+-Pour toutes les cartes du plateau de jeu située entre l'index début et la fin du plateau.
+
+	-On regarde si les cartes ont une **Figure** de type différent et de couleur identique au parametre **figure** envoyée dans la fonction.
+		-Si c'est le cas un ajoute l'index de cette carte dans une liste.
+		-Sinon rien.
+
+-Une fois toutes les cartes du plateau de jeu vérifiées, on retourne la liste d'index remplie
+
+---
+
+# RECHERCHE ENSEMBLE INTELLIGENT #
+
+-**Objectif**: Retourner une liste **d'Ensemble** contenant des ensembles de carte qui peuvent former un Swish par rapport à un indice de carte donné.
+
+**rechercherPertinent**(nbCarte: int, debut: int, carte: int): Ensemble[]
+
+**Entrées**:
+
+	-**nbCarte**: Information sur le nombre de **Cartes** que l'algorithme doit encore trouver pour chercher un SWISH à n **Cartes**
+
+	-**debut** : Indice dans le plateau de jeu du support du SWISH (première carte de l'empilement)
+
+	-**carte** : Indice dans le plateau de jeu de la carte que l'algorithme traite actuellement.
+
+**Sortie**
+
+	-**Ensemble[]** : Liste **d'Emssemble** contenant de liste d'indice pouvant potentiellement former des SWISH
+
+### COMMENT FAIRE ###
+
+-Si l'algorithme n'a plus de carte à rechercher (**nbCarte** = 0)
+
+	-On regarde si les figures de la première et de la dernière carte de l'ensemble sont complémentaire
+
+		- Si elles le sont, on ajoute l'indice de la carte que l'algorithme traite (**carte**) dans une structure **Ensemble** et on la retourne
+
+		- Si elles ne le sont pas, on ajoute l'indice de la carte que l'algorithme traite (**carte**) dans une structure **Ensemble** et on la retourne en notifiant **l'Enssemble** que cette liste est mauvaise.
+
+-On recupère tout les index des **Cartes** pouvant compléter le point de la **Carte** à l'index **carte**
+
+-Si la liste d'indice est vide alors on retourne un code d'erreur
+
+-Sinon pour chaque index de carte complémentaire on appelle récursivement cette fonction **recherchePertinente** en envoyant, nbCarte décrémenté, debut et l'indice de la carte.
+
+-Une fois tous ces résultats récupérés on les retournes.
+
+---
+
+
+# TEST DES ENSEMBLES #
+
+-**Objectif**: Tester tous les **Ensemble** d'une liste notifier et compter si les **Ensemble** sont correcte 
+
+**testAllEnsemble**(liste: Ensemble[]):int
+
+**Entrees** :
+
+	-**liste**: Liste **d'Ensemble** à tester
+
+**Sortie** :
+
+	-**int**: Correspond au nombre de Swish trouvé
+
+### COMMENT FAIRE ###
+
+-Pour toutes les **Ensembles** présents dans la liste
+
+	-On récupère les cartes correspondant aux indices
+
+		-Une fois toutes les cartes récupérées on teste notre tas dans la fonction **AssemblageARBRE**
+
+		-Si le SWISH est possible on incrémente le nombre de SWISH trouvé et on recommence avec le tas de carte suivant
+
+-Une fois tous les **Ensembles** on retourne le nombre de SWISH trouvé.
+
+---
+
+# TEST INTELLIGENT #
+
+
+-**Objectif**: Rechercher tous les SWISH possibles dans un plateau de jeu.
+
+-**testPertinent**(void):void
+
+### COMMENT FAIRE ###
+
+-Pour des tas allant de 2 à 5 **Carte**
+
+	-Pour chaque **Carte** du plateau de jeu
+
+			-On lance une **recherchePertinente** en envoyant le nombre de **Cartes** de notre tas, le numéro de la carte à partir de laquelle on veut les **Ensembles**possibles.
+
+	-Une fois tous les **Ensembles** récupérés on vérifie qu'il n'y a pas de doublon en lançant la fonction **comparaisonElement** de ces résultats.
+
+	-Une fois les doublons retirés on teste tous les **Ensembles** dans la fonction **testAllEnsemble**
+	-On affiche le nombre de SWISH trouvé et on fait apparaitre sur l'écran du joueur un SWISH à 5 cartes.
+
+---

SwichGIT/src/index.html

@@ -781,7 +781,7 @@
                 </a>
             </div>
             <div class="divmenu">
-                <a class="bouttonMenuHaut" onclick="test()">
+                <a class="bouttonMenuHaut" onclick="testPertinent()">
                     <div class="containButtonForm">
                         <i class="fas fa-search logoboutton"></i>
                     </div>

SwichGIT/src/js/main.js

@@ -1318,6 +1318,195 @@ function chercherCombinaison() {
 	window.alert("Nombre de combinaison: " + Cptsolution);
 }
 
+function testPertinent() {
+	//test();
+	var allComb = 0;
+	//window.alert("Voici ce que j'ai trouvé, mais voulez vous booster mes recherches ?")
+	console.log("===============!!!! BOOST !!!!=============")
+	for (var i = 2; i < 6; i++) {
+		var tabCheck = [];
+		for (var j = 0; j < 16 - i + 1; j++) {
+			var tab = recherchePertinente(i, j, j);
+			for (var m = 0; m < tab.length; m++) {
+				tabCheck.push(tab[m]);
+			}
+
+		}
+		//console.log("J'ai tout les ensembles pour " + i + " cartes " + tabCheck.length)
+		var tabInte = comparaisonEmpilement(tabCheck, 0);
+		//console.log("nouveau tableau avec " + tabInte.length)
+		allComb += testAllEnsemble(tabInte);
+	}
+	console.log("nb combi : " + allComb)
+	window.alert("Et voilà ! J'ai finis !")
+}
+
+function comparaisonEmpilement(liste, debut) {
+	if (debut >= liste.length - 1) {
+		return liste;
+	}
+	var tabPropre = [];
+	for (var j = 0; j <= debut; j++) {
+		tabPropre.push(liste[j]);
+	}
+	var sommeCarreEle = sommeCarreElement(liste[debut].ensemble);
+	for (var i = debut + 1; i < liste.length; i++) {
+		if (sommeCarreEle != sommeCarreElement(liste[i].ensemble)) {
+			tabPropre.push(liste[i]);
+		} else {
+			//console.log("==========DOUBLON==========")
+			//console.log(sommeCarreEle + " ===== " + sommeCarreElement(liste[i].ensemble))
+		}
+	}
+	//console.log(tabPropre.length + " ========== " + liste.length)
+	var tabRetour = comparaisonEmpilement(tabPropre, debut + 1);
+	return tabRetour;
+}
+function sommeCarreElement(element) {
+	var sommeCarre = 0;
+	for (var i = 0; i < element.length; i++) {
+		sommeCarre += Math.pow(2, element[i]);
+	}
+	return sommeCarre;
+}
+
+function selectionAuto(liste) {
+	while (carteselect.length != 0) {
+		var id = "card" + carteselect[0].identifiant;
+		document.getElementById(id).style.boxShadow = "";
+		carteselect.splice(0, 1);
+	}
+	for (var i = 0; i < liste.length; i++) {
+		var id = "card" + deckPartie[liste[i]].identifiant;
+		document.getElementById(id).style.boxShadow = "0 0 1vw red, 0 0 1vw red";
+		carteselect.push(deckPartie[liste[i]]);
+	}
+}
+
+function testAllEnsemble(liste) {
+	var tabCode = [];
+	var compteur = 0;
+	for (var i = 0; i < liste.length; i++) {
+		var lesCartes = [];
+		for (var j = 0; j < liste[i].ensemble.length; j++) {
+			lesCartes.push(deckPartie[liste[i].ensemble[j]]);
+		}
+		var tab = AssemblageARBRE(copieListeDeCarte(lesCartes), copieCarte(lesCartes[0]));
+		//Recupération de code
+		var solution = true;
+		for (var h = 0; h < tab.length; h++) {
+			tabCode.push(tab[h].code);
+		}
+		//Reagarde si il y a une solution
+		for (var g = 0; g < tab.length; g++) {
+			if (tab[g].code == lesCartes.length) {
+				solution = false;
+			}
+		}
+		//Reagarde si il y a une solution
+		if (!solution) {
+			selectionAuto(liste[i].ensemble);
+			//console.log("==========================")
+			console.log("Combinaison à " + (lesCartes.length) + " cartes trouvée : " + liste[i].ensemble);
+			compteur++;
+			//console.log(sommeCarreElement(liste[i].ensemble))
+		}
+	}
+	return compteur;
+}
+
+class Ensemble {
+	constructor(valeur, index) {
+		this.v = valeur;
+		this.ensemble = [];
+		this.ensemble.push(index);
+	}
+}
+
+function recherchePertinente(nbCarte, debut, carte) {
+	tabRetour = [];
+	nbCarte = nbCarte - 1;
+
+	//Si il n'y a  plus de carte à ajouter dans l'ensemble on regarde si la boucle de peut se boucler
+	if (nbCarte == 0) {
+		var laPremiereCarte = deckPartie[debut];
+		for (var i = 0; i < deckPartie[carte].SesFigures.length; i++) {
+			for (var j = 0; j < laPremiereCarte.SesFigures.length; j++) {
+				if (deckPartie[carte].SesFigures[i].type[0] == TypeFigure.Petit && laPremiereCarte.SesFigures[j].type[0] == TypeFigure.Moyen) {
+					if (deckPartie[carte].SesFigures[i].couleur == laPremiereCarte.SesFigures[j].couleur) {
+						tabRetour.push(new Ensemble(0, carte));
+						return tabRetour;
+					} else {
+						tabRetour.push(new Ensemble(-1, carte));
+						return tabRetour;
+					}
+				}
+			}
+		}
+	}
+
+	//On recupère tout les index des cartes pouvant compléter le point de la carte à l'index "carte"
+	for (var i = 0; i < deckPartie[carte].SesFigures.length; i++) {
+		if (deckPartie[carte].SesFigures[i].type[0] == TypeFigure.Petit) {
+			var lePoint = deckPartie[carte].SesFigures[i];
+		}
+	}
+	var listeCarteComp = carteComplementaire(lePoint, debut);
+	//Si la liste de carte complémentaire est vide alors on retourne un code d'erreur
+	if (listeCarteComp.length == 0) {
+		tabRetour.push(new Ensemble(-1, carte));
+		return tabRetour;
+	}
+
+	//Sinon pour chaque index de carte complémentaire on continue la recherche pertinente
+	var tabPropre = [];
+	for (var i = 0; i < listeCarteComp.length; i++) {
+		var tab = [];
+		var unTabEnsemble = [];
+		tab.push(recherchePertinente(nbCarte, debut, listeCarteComp[i]));
+
+		for (var k = 0; k < tab[0].length; k++) {
+			unTabEnsemble.push(tab[0][k]);
+		}
+
+		for (var j = 0; j < unTabEnsemble.length; j++) {
+			if (unTabEnsemble[j].v == 0) {
+				var present = false;
+				for (var m = 0; m < unTabEnsemble[j].ensemble.length; m++) {
+					if (unTabEnsemble[j].ensemble[m] == carte) {
+						present = true;
+					}
+				}
+				if (!present) {
+					unTabEnsemble[j].ensemble.push(carte);
+					tabPropre.push(unTabEnsemble[j]);
+				}
+			}
+		}
+
+	}
+
+	return tabPropre;
+
+
+
+}
+
+function carteComplementaire(figure, debut) {
+	var retour = [];
+	//Pour toutes les cartes de deckpartie après la carte de début, on regarde les ronds des cartes et on regarde leurs couleurs pour les faire remonter.
+	for (var i = debut + 1; i < 16; i++) {
+		for (var j = 0; j < deckPartie[i].SesFigures.length; j++) {
+			if (deckPartie[i].SesFigures[j].type[0] == TypeFigure.Moyen) {
+				if (deckPartie[i].SesFigures[j].couleur == figure.couleur) {
+					retour.push(i);
+				}
+			}
+		}
+	}
+	return retour;
+}
+
 function test() {
 	printCombinations([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], 12);
 }