Feat: Implémentation de pushDown et prévention double fusion

- Implémentation de la méthode pushDown dans Game.java pour le mouvement/fusion vers le bas.
- Ajout de la logique 'alreadyCombined' dans pushUp et pushDown pour empêcher
  une tuile de fusionner plus d'une fois par mouvement.
- Ajout de logs de débogage pour pushUp/pushDown.
- Mise à jour de MainActivity pour tester pushDown.

app/src/main/java/legion/muyue/best2048/Game.java

@@ -13,7 +13,6 @@ public class Game {
     public Game() {
         gameBoard = new int[4][4];
         random = new Random();
-        // Le score est initialisé à 0 par défaut
     }
 
     public void printArray() {
@@ -53,38 +52,84 @@ public class Game {
         }
     }
 
+
     public void pushUp() {
-        // Itération sur chaque colonne
+        Log.d("Game", "Pushing Up"); // Pour le débogage
+        boolean[] alreadyCombined = new boolean[4]; // Tableau pour éviter les doubles fusions par colonne
+
         for (int y = 0; y < 4; y++) {
-            // Itération sur chaque ligne de la colonne en commençant par la deuxième ligne (index 1)
+            alreadyCombined = new boolean[4]; // Réinitialise pour chaque colonne
             for (int x = 1; x < 4; x++) {
-                // Si la case actuelle n'est pas vide
                 if (gameBoard[x][y] != 0) {
-                    int value = gameBoard[x][y]; // Stocke la valeur de la case actuelle
+                    int value = gameBoard[x][y];
-                    int currentX = x; // Variable pour suivre la position courante lors du déplacement vers le haut
+                    int currentX = x;
 
-                    // Déplacement vers le haut tant que la case précédente est vide et qu'on n'est pas en haut du tableau
                     while (currentX > 0 && gameBoard[currentX - 1][y] == 0) {
-                        currentX--; // Décrémente pour remonter d'une ligne
+                        currentX--;
                     }
 
-                    // Traitement des cas après le déplacement
+                    if (currentX == 0) {
-                    if (currentX == 0) { // Si on est arrivé en haut du tableau
+                        gameBoard[0][y] = value;
-                        gameBoard[0][y] = value; // Place la valeur en haut
+                        if (currentX != x)
+                            gameBoard[x][y] = 0;
+                    } else if (gameBoard[currentX - 1][y] != value) {
+                        gameBoard[currentX][y] = value;
+                        if (currentX != x)
+                            gameBoard[x][y] = 0;
+                    } else if (!alreadyCombined[currentX - 1]) {
+                        gameBoard[currentX - 1][y] *= 2;
+                        score += gameBoard[currentX - 1][y];
+                        gameBoard[x][y] = 0;
+                        alreadyCombined[currentX - 1] = true;
+                    } else {
+                        // La case cible a déjà fusionné, on place la tuile juste en dessous
+                        gameBoard[currentX][y] = value;
                         // Vide la case d'origine seulement si la tuile a bougé
                         if (currentX != x) {
                             gameBoard[x][y] = 0;
                         }
-                    } else if (gameBoard[currentX - 1][y] != value) { // Si la case précédente a une valeur différente
+                    }
-                        gameBoard[currentX][y] = value;   // Place la valeur à la position actuelle (juste en dessous de la case différente)
+                }
-                        // Vide la case d'origine seulement si la tuile a bougé
+            }
+        }
+    }
+
+    public void pushDown() {
+        Log.d("Game", "Pushing Down"); // Pour le débogage
+        boolean[] alreadyCombined = new boolean[4]; // Tableau pour éviter les doubles fusions par colonne
+
+        for (int y = 0; y < 4; y++) {
+            alreadyCombined = new boolean[4]; // Réinitialise pour chaque colonne
+            for (int x = 2; x >= 0; x--) { // Commence à l'avant-dernière ligne et remonte
+                if (gameBoard[x][y] != 0) {
+                    int value = gameBoard[x][y];
+                    int currentX = x;
+
+                    // Déplace vers le bas tant que la case en dessous est vide
+                    while (currentX < 3 && gameBoard[currentX + 1][y] == 0) {
+                        currentX++; // Incrémente pour descendre d'une ligne
+                    }
+
+                    if (currentX == 3) { // Arrivé tout en bas
+                        gameBoard[3][y] = value;
+                        if (currentX != x) // Vide seulement si déplacé
+                            gameBoard[x][y] = 0;
+                    } else if (gameBoard[currentX + 1][y] != value) { // Case en dessous différente
+                        gameBoard[currentX][y] = value; // Place juste au-dessus
+                        if (currentX != x) // Vide seulement si déplacé
+                            gameBoard[x][y] = 0;
+                    } else if (!alreadyCombined[currentX + 1]) { // Case en dessous identique ET non fusionnée
+                        gameBoard[currentX + 1][y] *= 2; // Fusionne
+                        score += gameBoard[currentX + 1][y];
+                        gameBoard[x][y] = 0; // Vide la case d'origine
+                        alreadyCombined[currentX + 1] = true; // Marque comme fusionné
+                    } else {
+                        // La case cible a déjà fusionné, on place la tuile juste au-dessus
+                        gameBoard[currentX][y] = value;
+                        // Vide seulement si déplacé
                         if (currentX != x) {
                             gameBoard[x][y] = 0;
                         }
-                    } else { // Si la case précédente a la même valeur (Cas de fusion)
-                        gameBoard[currentX - 1][y] *= 2; // Double la valeur de la case précédente (fusion)
-                        score += gameBoard[currentX - 1][y]; // Ajoute le résultat de la fusion au score
-                        gameBoard[x][y] = 0;   // Vide la case d'origine (toujours nécessaire en cas de fusion)
                     }
                 }
             }

app/src/main/java/legion/muyue/best2048/MainActivity.java

@@ -11,13 +11,19 @@ public class MainActivity extends AppCompatActivity {
 
         Game game = new Game();
 
-        // Initialisation avec quelques tuiles pour le test
+        // Initialisation et tests plus systématiques
         game.addNewNumbers();
         game.addNewNumbers();
         game.addNewNumbers();
+        game.printArray(); // Grille initiale
 
-        game.printArray(); // Affichage initial
+        game.pushUp();
-        game.pushUp();     // Appel de pushUp()
+        game.printArray(); // Après pushUp
-        game.printArray(); // Affichage après pushUp()
+
+        game.addNewNumbers(); // Ajoute une autre tuile
+        game.printArray(); // Grille avant pushDown
+
+        game.pushDown();
+        game.printArray(); // Après pushDown
     }
 }