gamemanager.cpp

#include "gamemanager.h"
#include "random"

GameManager::GameManager(QObject *parent) : QObject(parent), grid(4, std::vector<int>(4, 0)) {

}

void GameManager::moveLeft() {
    for (int i = 0; i < 4; i++) {
        std::vector<int> newRow(4, 0);  // Créer une nouvelle ligne vide
        int newPos = 0;  // Position pour insérer un élément non nul (commence par le début)
        int temp = 0;  // Variable pour mémoriser l'élément à fusionner

        // Parcourir la ligne de gauche à droite
        for (int j = 0; j <4; j++) {
            if (grid[i][j] != 0) {  // Si l'élément n'est pas nul
                if (temp == 0) {
                    // Mémoriser l'élément actuel
                    temp = grid[i][j];
                } else if (temp == grid[i][j]) {
                    // Si l'élément est identique au "temp", fusionner
                    newRow[newPos] = temp * 2;  // Fusionner en doublant la valeur
                    temp = 0;  // Réinitialiser temp après fusion
                    newPos++;  // Déplacer la position pour l'élément suivant
                } else {
                    // Si l'élément n'est pas identique à "temp", le placer dans la nouvelle ligne
                    newRow[newPos] = temp;
                    temp = grid[i][j];  // Mettre à jour temp avec le nouvel élément
                    newPos++;  // Déplacer la position pour l'élément suivant
                }
            }
        }

        // Si l'élément restant dans "temp" n'a pas été placé, on le place
        if (temp != 0) {
            newRow[newPos] = temp;
        }

        // Mettre à jour la grille avec la nouvelle ligne
        grid[i] = newRow;
    }
    emit addRandomElement();

    //Mettre a jour l'état et l'enregistrer
    historyArray.append(gridToJsonArray());
    emit gridChanged();
}

void GameManager::moveRight() {
    for (int i = 0; i < 4; i++) {
        std::vector<int> newRow(4, 0);  // Créer une nouvelle ligne vide
        int newPos = 3;  // Position pour insérer un élément non nul (commence par la fin)
        int temp = 0;  // Variable pour mémoriser l'élément à fusionner

        // Parcourir la ligne de droite à gauche
        for (int j = 3; j >= 0; j--) {
            if (grid[i][j] != 0) {  // Si l'élément n'est pas nul
                if (temp == 0) {
                    // Mémoriser l'élément actuel
                    temp = grid[i][j];
                } else if (temp == grid[i][j]) {
                    // Si l'élément est identique au "temp", fusionner
                    newRow[newPos] = temp * 2;  // Fusionner en doublant la valeur
                    temp = 0;  // Réinitialiser temp après fusion
                    newPos--;  // Déplacer la position pour l'élément suivant
                } else {
                    // Si l'élément n'est pas identique à "temp", le placer dans la nouvelle ligne
                    newRow[newPos] = temp;
                    temp = grid[i][j];  // Mettre à jour temp avec le nouvel élément
                    newPos--;  // Déplacer la position pour l'élément suivant
                }
            }
        }

        // Si l'élément restant dans "temp" n'a pas été placé, on le place
        if (temp != 0) {
            newRow[newPos] = temp;
        }

        // Mettre à jour la grille avec la nouvelle ligne
        grid[i] = newRow;
    }
    emit addRandomElement();

    //Mettre a jour l'état et l'enregistrer
    historyArray.append(gridToJsonArray());
    emit gridChanged();

}



void GameManager::moveUp() {
    // Implémentation du mouvement vers le haut
    for (int j = 0; j < 4; j++) {
        std::vector<int> newCol(4, 0);  // Créer une nouvelle ligne vide
        int newPos = 0;  // Position pour insérer un élément non nul (commence par la fin)
        int temp = 0;  // Variable pour mémoriser l'élément à fusionner

        // Parcourir la ligne de droite à gauche
        for (int i = 0; i <4; i++) {
            if (grid[i][j] != 0) {  // Si l'élément n'est pas nul
                if (temp == 0) {
                    // Mémoriser l'élément actuel
                    temp = grid[i][j];
                } else if (temp == grid[i][j]) {
                    // Si l'élément est identique au "temp", fusionner
                    newCol[newPos] = temp * 2;  // Fusionner en doublant la valeur
                    temp = 0;  // Réinitialiser temp après fusion
                    newPos++;  // Déplacer la position pour l'élément suivant
                } else {
                    // Si l'élément n'est pas identique à "temp", le placer dans la nouvelle ligne
                    newCol[newPos] = temp;
                    temp = grid[i][j];  // Mettre à jour temp avec le nouvel élément
                    newPos++;  // Déplacer la position pour l'élément suivant
                }
            }
        }

        // Si l'élément restant dans "temp" n'a pas été placé, on le place
        if (temp != 0) {
            newCol[newPos] = temp;
        }

        // Mettre à jour la colonne dans la grille
        for (int i=0;i<4;i++){
            grid[i][j]=newCol[i];
        }

    }
    emit addRandomElement();

    //Mettre a jour l'état et l'enregistrer
    historyArray.append(gridToJsonArray());
    emit gridChanged();
}

void GameManager::moveDown() {
    // Implémentation du mouvement vers le bas
    for (int j = 0; j < 4; j++) {
        std::vector<int> newCol(4, 0);  // Créer une nouvelle ligne vide
        int newPos = 3;  // Position pour insérer un élément non nul (commence par la fin)
        int temp = 0;  // Variable pour mémoriser l'élément à fusionner

        // Parcourir la ligne de droite à gauche
        for (int i = 3; i>=0; i--) {
            if (grid[i][j] != 0) {  // Si l'élément n'est pas nul
                if (temp == 0) {
                    // Mémoriser l'élément actuel
                    temp = grid[i][j];
                } else if (temp == grid[i][j]) {
                    // Si l'élément est identique au "temp", fusionner
                    newCol[newPos] = temp * 2;  // Fusionner en doublant la valeur
                    temp = 0;  // Réinitialiser temp après fusion
                    newPos--;  // Déplacer la position pour l'élément suivant
                } else {
                    // Si l'élément n'est pas identique à "temp", le placer dans la nouvelle ligne
                    newCol[newPos] = temp;
                    temp = grid[i][j];  // Mettre à jour temp avec le nouvel élément
                    newPos--;  // Déplacer la position pour l'élément suivant
                }
            }
        }

        // Si l'élément restant dans "temp" n'a pas été placé, on le place
        if (temp != 0) {
            newCol[newPos] = temp;
        }

        // Mettre à jour la colonne dans la grille
        for (int i=0;i<4;i++){
            grid[i][j]=newCol[i];
        }

    }
    emit addRandomElement();

    //Mettre a jour l'état et l'enregistrer
    historyArray.append(gridToJsonArray());
    emit gridChanged();

}

void GameManager::restartGame() {

    //sauvergarder la partie précédente

    enregistrerPartie();

    // Réinitialisation des variables
    grid.assign(4, std::vector<int>(4, 0));
    historyArray = QJsonArray();

    std::random_device rd;
    std::uniform_int_distribution<int> distrib(0, 15);

    int num1 = distrib(rd);
    int num2 = distrib(rd);

    // Assure que num2 est différent de num1
    do {
        num2 = distrib(rd);
    } while (num2 == num1);

    int rg1= num1/4;
    int col1= num1 - (4*rg1);

    int rg2= num2/4;
    int col2= num2 - (4*rg2);

    grid[rg1][col1]=2;
    grid[rg2][col2]=2;


    //Mettre a jour l'état et l'enregistrer
    historyArray.append(gridToJsonArray());
    emit gridChanged();

}

void GameManager::addRandomElement() {
    // Créer une liste pour stocker les indices des cases vides
    std::vector<std::pair<int, int>> emptyCells;

    // Parcourir la grille pour trouver toutes les cases vides
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            if (grid[i][j] == 0) {  // Si la case est vide (valeur 0)
                emptyCells.push_back({i, j});  // Ajouter l'indice de la case à la liste
            }
        }
    }

    // Si la liste des cases vides n'est pas vide, on ajoute un nouveau '2'
    if (!emptyCells.empty()) {
        // Choisir une case vide aléatoire
        int randomIndex = rand() % emptyCells.size();
        int row = emptyCells[randomIndex].first;
        int col = emptyCells[randomIndex].second;

        // Placer un '2' dans cette case
        grid[row][col] = 2;
    }
}

QVector<int> GameManager::getGridValues() const {
    QVector<int> flattenedGrid;
    for (const auto& row : grid) {  // Parcourt chaque ligne
        for (int value : row) {      // Parcourt chaque colonne
            flattenedGrid.append(value);
        }
    }
    return flattenedGrid;
}

QJsonArray GameManager::gridToJsonArray() {
    QJsonArray jsonGrid;
    for (const auto &row : grid) {
        QJsonArray jsonRow;
        for (int cell : row) {
            jsonRow.append(cell);
        }
        jsonGrid.append(jsonRow); // Ajoute chaque ligne
    }
    return jsonGrid;
}

void GameManager::undo() {
    if (historyArray.size() > 1) {  // Vérifiez qu'il y a au moins deux états
        historyArray.removeLast();  // Supprimez le dernier état
        QJsonArray previousState = historyArray.last().toArray();  // Récupérez l'avant-dernier état

        // Mettez à jour la grille avec l'état précédent
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                grid[i][j] = previousState[i].toArray()[j].toInt();
            }
        }

        emit gridChanged();  // Notifiez que la grille a changé
    }
}

void GameManager::enregistrerPartie(){

}