merged

motus/brain.cpp

@@ -4,7 +4,12 @@
 #include <iostream>
 #include <filesystem>
 #include "grillemanager.h"
+<<<<<<< HEAD
 #include "fullligneexception.h"
+=======
+#include <QString>
+
+>>>>>>> e6f8b0eb13207f90ae4ed37356359f928e941f2a
 
 using namespace std;
 namespace fs = std::filesystem;
@@ -91,8 +96,8 @@ void Brain::setNombreEssais(int nbEssais) {mNbEssaisMax = nbEssais;}
 void Brain::setTailleMots(int tailleMot) {mTailleMot = tailleMot;}
 string Brain::getMot() {return mot;}
 
+
 void Brain::initGame() {
-    // Appelé lorsqu'on appuie sur le bouton Start Game
     try {
         trouveMot();
         cout << "Réponse : [";
@@ -104,15 +109,19 @@ void Brain::initGame() {
             lignes.push_back(new Ligne(getMot()));
             lignes[i]->initLigne();
         }
-    }
-    catch (NoWordException e) {
+
+        // Convertir std::string (getMot()) en QString
+        QString motQString = QString::fromStdString(getMot());  // Conversion de std::string en QString
+        GrilleManager grille(motQString);  // Passer le QString à GrilleManager
+        grille.createGrid(mNbEssaisMax, mTailleMot);  // Créer la grille
+    } catch (NoWordException e) {
         cout << e.what() << endl;
     }
-
-    GrilleManager grille;
-    grille.createGrid(mNbEssaisMax, mTailleMot);
 }
 
+
+
+
 void Brain::validateWord() {
     // Appelé lorsqu'on appuie sur le bouton validate du clavier
     cout << "Validation de la ligne !" << endl;

motus/grillemanager.cpp

 #include "grillemanager.h"
 
-GrilleManager::GrilleManager(QObject *parent) : QObject(parent) {
-    // Initialisation avec une grille vide
-    m_cases.clear();
+GrilleManager::GrilleManager(const QString &mot, QObject *parent)
+    : QObject(parent), m_mot(mot) {
+    // Initialisation de la grille (si tu veux le faire immédiatement dans le constructeur)
+    createGrid(6, m_mot.length());  // Exemple : 6 essais, longueur du mot
 }
 
 void GrilleManager::createGrid(int rows, int columns) {
     m_cases.clear();  // Vide la grille avant de la remplir
 
-    int totalCases = rows * columns;
-    for (int i = 0; i < totalCases; ++i) {
-        auto *vraieCase = new VraieCase(this);
-        vraieCase->setLetter('_');  // Exemple : lettres de A à Z
-        vraieCase->setEtat(0);  // Exemple : état cyclique (0,1,2)
+    // Remplir la grille avec des cases
+    for (int i = 0; i < rows * columns; ++i) {
+        VraieCase *vraieCase = new VraieCase(this);
+
+        // Si on est à la première case, on met la première lettre du mot, sinon on met '_'
+        if (i < m_mot.length()) {
+            vraieCase->setLetter(m_mot[i]);  // Conversion automatique depuis QString
+        } else {
+            vraieCase->setLetter(QString("_"));  // Conversion du char '_' en QString
+        }
+
+        vraieCase->setEtat(0);  // Tu peux définir l'état comme tu veux
         m_cases.append(vraieCase);
     }
 
-    emit casesChanged();
+    emit casesChanged();  // Émettre le signal pour indiquer que la grille a changé
 }
 
 QQmlListProperty<VraieCase> GrilleManager::getCases() {

motus/grillemanager.h

@@ -10,18 +10,16 @@ class GrilleManager : public QObject {
     Q_PROPERTY(QQmlListProperty<VraieCase> cases READ getCases NOTIFY casesChanged)
 
 public:
-    explicit GrilleManager(QObject *parent = nullptr);
-
-    // Fonction pour créer une grille de taille variable
-    Q_INVOKABLE void createGrid(int rows, int columns);
-
-    QQmlListProperty<VraieCase> getCases();
+    explicit GrilleManager(const QString &mot, QObject *parent = nullptr);  // Le mot en argument
+    void createGrid(int rows, int columns);  // Créer la grille
+    QQmlListProperty<VraieCase> getCases();  // Obtenir les cases
 
 signals:
     void casesChanged();
 
 private:
-    QList<VraieCase*> m_cases;
+    QString m_mot;
+    QList<VraieCase *> m_cases;  // Liste des cases de la grille
 };
 
 #endif // GRILLEMANAGER_H

motus/jeu.cpp

 #include "jeu.h"
 #include <iostream>
 
-Jeu::Jeu(QObject *parent) : QObject(parent), brain("./") {
 
 
-    mot = QString::fromStdString(brain.getMot()); // ✅ Conversion std::string → QString
+Jeu::Jeu(QObject *parent) : QObject(parent), brain("./"), grilleManager("", this) {
+}
 
-    std::cout << "Mot choisi : " << mot.toStdString() << std::endl;
+void Jeu::setMot(const QString& mot) {
+    this->mot = mot;
+    grilleManager.createGrid(mot.length(), 1); // Utilise la longueur du mot pour la grille
+    emit motChanged();
 }
 
-QString Jeu::getMotAffiche() {
-    if (mot.isEmpty()) return "";
 
-    QString affichage = QString(mot.at(0));
-    for (int i = 1; i < mot.length(); ++i) {
-        affichage += " _";
-    }
-    return affichage;
+QString Jeu::getMotAffiche() {
+    return mot;
 }
 
+
 void Jeu::onClavierClick(QString lettre) {
     brain.entreLettre(lettre.toStdString()[0]);
 }
@@ -31,8 +30,8 @@ void Jeu::initGame() {
 void Jeu::startGame() {
     brain.setFichierDico("words_alpha.txt");
 
-    brain.setNombreEssais(6); // ou ce que tu veux
-    brain.setTailleMots(5);   // idem
+    brain.setNombreEssais(6);
+    brain.setTailleMots(5);
 
     brain.initGame();
 

motus/jeu.h

@@ -16,9 +16,9 @@ public:
     Q_INVOKABLE void onClavierClick(QString lettre);
     Q_INVOKABLE void initGame();
     Q_INVOKABLE void startGame(); // pour init depuis QML
+    Q_INVOKABLE void setMot(const QString& mot); // Ajouter cette méthode pour définir le mot
     GrilleManager* getGrilleManager() { return &grilleManager; }
 
-
 signals:
     void motChanged();
 

motus/ligne.cpp

 #include "ligne.h"
 #include "fullligneexception.h"
 #include "emptyligneexception.h"
+<<<<<<< HEAD
 #include "iostream"
 #include <cctype>
 using namespace std;
+=======
+#include <QString>
+>>>>>>> e6f8b0eb13207f90ae4ed37356359f928e941f2a
 
 Ligne::Ligne(string bonmot) : bonmot(bonmot), positionCurseur(0) {}
 
-
 void Ligne::initLigne() {
     for (int i = 0; i < bonmot.length(); i++) {
         contenu.push_back(new VraieCase());
@@ -50,7 +53,7 @@ void Ligne::entreLettre(char lettre) {
     if (positionCurseur == bonmot.length()) {
         throw FullLigneException();
     }
-    contenu[positionCurseur]->setLetter(lettre);
+    contenu[positionCurseur]->setLetter(QChar(lettre));  // Conversion ici
     positionCurseur++;
 }
 
@@ -59,6 +62,6 @@ void Ligne::supprLettre() {
         throw EmptyLigneException();
     }
     cout << "Suppression d'une lettre" << endl;
-    contenu[positionCurseur - 1]->setLetter(' ');
+    contenu[positionCurseur - 1]->setLetter(QChar(' '));
     positionCurseur--;
 }

motus/ligne.h

@@ -29,7 +29,7 @@ private:
     int taille;
     vector<VraieCase*> contenu;
 
-    static bool dansMot(char lettre, string mot);
+static bool dansMot(QChar lettre, std::string mot);
 };
 
 #endif // LIGNE_H

motus/main.cpp

@@ -9,13 +9,14 @@ int main(int argc, char *argv[]) {
     QGuiApplication app(argc, argv);
     QQmlApplicationEngine engine;
 
-
     qmlRegisterType<VraieCase>("motus", 1, 0, "VraieCase");
     qmlRegisterType<GrilleManager>("motus", 1, 0, "GrilleManager");
 
+    // Créer l'objet Jeu sans mot
     Jeu jeu;
     engine.rootContext()->setContextProperty("jeu", &jeu);
 
+    // Charger l'interface utilisateur (QML)
     engine.loadFromModule("motus", "Main");
 
     return app.exec();

motus/vraiecase.cpp

 #include "vraiecase.h"
 
-VraieCase::VraieCase(QObject *parent) : lettre(' '), etat(0) {}
+VraieCase::VraieCase(QObject *parent) : QObject(parent), lettre(""), etat(0) {}
 
-char VraieCase::getLetter() const { return lettre; }
-void VraieCase::setLetter(char letter) {
+QString VraieCase::getLetter() const {
+    return lettre;
+}
+
+void VraieCase::setLetter(const QString &letter) {
     if (lettre != letter) {
         lettre = letter;
         emit letterChanged();
     }
 }
 
-int VraieCase::getEtat() const { return etat; }
-void VraieCase::setEtat(int etat) {
-    if (this->etat != etat) {
-        this->etat = etat;
+int VraieCase::getEtat() const {
+    return etat;
+}
+
+void VraieCase::setEtat(int e) {
+    if (etat != e) {
+        etat = e;
         emit etatChanged();
     }
 }

motus/vraiecase.h

@@ -2,17 +2,18 @@
 #define VRAIECASE_H
 
 #include <QObject>
+#include <QString>
 
 class VraieCase : public QObject {
     Q_OBJECT
-    Q_PROPERTY(char letter READ getLetter WRITE setLetter NOTIFY letterChanged)
+    Q_PROPERTY(QString letter READ getLetter WRITE setLetter NOTIFY letterChanged)
     Q_PROPERTY(int etat READ getEtat WRITE setEtat NOTIFY etatChanged)
 
 public:
     explicit VraieCase(QObject *parent = nullptr);
 
-    char getLetter() const;
-    void setLetter(char letter);
+    QString getLetter() const;
+    void setLetter(const QString &letter);  // Mise à jour du type
 
     int getEtat() const;
     void setEtat(int etat);
@@ -22,7 +23,7 @@ signals:
     void etatChanged();
 
 private:
-    char lettre;
+    QString lettre;
     int etat;
 };