Implémentation incomplète de la fonction d'exploitation du GADDAG

src/test_board.cpp

@@ -8,7 +8,7 @@
 #include <string.h>
 
 enum Direction { left, down, up, right };
-void exploitation(const Board& b, int x, int y, Direction d, const Joueur& j, TrieNode* n);
+void exploitation(Board& b, int x, int y, Direction d, const Joueur& j, TrieNode* n);
 
 void sort_wrong_words(const char* dico_path, const char* filtered_path);
 
@@ -46,17 +46,94 @@ int main()
 	
 	Gaddag gaddag("../data/filtered_dico.txt");
 
-	exploitation(b, 0, 0, up, plateau.get_joueur(0), gaddag.get_root());
+	exploitation(b, 9, 7, up, plateau.get_joueur(0), gaddag.get_root());
+	exploitation(b, 9, 7, up, plateau.get_joueur(1), gaddag.get_root());
+	exploitation(b, 9, 7, up, plateau.get_joueur(2), gaddag.get_root());
+
+	std::cout << b << std::endl;
 
 	return 0;
 }
 
-void exploitation(const Board& b, int x, int y, Direction d, const Joueur& j, TrieNode* n)
+// pour l'instant cette fonction s'occupe uniquement de trouver un mot possible
+// (sans tenir compte des cases aux alentours) puis le place sur le board
+void exploitation(Board& b, int x, int y, Direction d, const Joueur& j, TrieNode* n)
 {
+	char letter = b(y, x).letter;
 	std::unordered_multiset<char> lettres_j = j.get_lettres();
-	for (char lettre : lettres_j)
-		std::cout << lettre;
-	std::cout << std::endl;
+	{
+		auto iter = lettres_j.find(letter);
+		if (iter == lettres_j.end())
+			// sortir de la fonction si nous n'avons pas la lettre recherchée dans le sac
+			return;
+		// l'enlever du sac si elle était dedans
+		lettres_j.erase(iter);
+	}
+	bool reversed = true;
+	bool end_of_word = false;
+	// variable qui va nous permettre de savoir où placer les lettres trouvées
+	int move = 0;
+	// map pour stocker les lettres à placer pour les placer uniquement après
+	// qu'on sait que le mot est valide
+	std::unordered_map<int, char> lettres;
+	std::string word = "";
+	n = n->children[letter];
+	word += letter;
+	while (!n->children.empty()) {
+		// compteur de nœuds visités pour savoir quand on a itéré sur l'entièreté des enfants
+		// c.-à-d. nous ne pouvons pas aller plus loin dans la construction du mot
+		int nb = 0, nb_max = n->children.size();
+		for (std::pair<char, TrieNode*> child : n->children) {
+			nb++;
+			if (child.first == '+') {
+				n = child.second;
+				reversed = false;
+				// on réinitialise à la position d'origine pour bouger ensuite
+				move = 0;
+				break;
+			}
+			auto iter = lettres_j.find(child.first);
+			if (iter != lettres_j.end()) {
+				if (reversed)
+					word = *iter + word;
+				else
+					word = word + *iter;
+				// si nous allons vers le bas ou vers la droite, alors nous allons
+				// bouger positivement. sinon, nous bougeons négativement.
+				// cependant, si reversed est vrai, alors nous bougeons dans
+				// le sens opposé.
+				lettres[((d == down || d == right) ? ++move : --move)*(-1*(reversed ? 1 : -1))] = *iter;
+				lettres_j.erase(iter);
+				// dès qu'on trouve une paire qui contient une lettre dans notre sac,
+				// on poursuit en allant dans son nœud
+				n = child.second;
+				//
+				// Q : ça veut dire qu'on ne teste pas toutes les autres possibilités ?
+				// Que si M vient avant U, on se retrouvera à ne pas avoir un mot
+				// complet avec M alors qu'on aurait pu si on avait aussi essayé
+				// de voir les enfants de U ?
+				//
+				// A : oui, il faudrait sûrement faire des appels récursifs pour ça
+				//
+				end_of_word = n->is_end_of_word;
+				// termine la fonction dès qu'on a trouvé un mot valide
+				// On aura donc toujours le mot le plus court possible
+				if (end_of_word)
+					goto exit;
+				break;
+			}
+			if (nb == nb_max)
+				goto exit;
+		}
+	}
+	exit:
+	std::cout << word << std::endl;
+	std::cout << "mot fini ? " << (end_of_word ? "oui" : "non") << std::endl;
+	// seulement affecter les lettres si nous avons un mot valide
+	if (!end_of_word)
+		return;
+	for (std::pair<int, char> lettre : lettres)
+		b(y + lettre.first*(d == up || d == down), x + lettre.first*(d == right || d == left)).letter = lettre.second;
 }
 
 void sort_wrong_words(const char* dico_path, const char* filtered_path) {