Modification dans le EtatJeu dans la logique apres quelque bug

src/main/java/sae/chuzzle/EtatJeu.java

@@ -1,5 +1,7 @@
 package sae.chuzzle;
 
+import android.os.Bundle;
+
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
@@ -50,6 +52,47 @@ public class EtatJeu {
         return partieTerminee;
     }
 
+    // -
+    //  SAUVEGARDE ET RESTAURATION
+
+    public void sauvegarderEtat(Bundle bundle) {
+        int[] flatGrille = new int[NB_LIGNES * NB_COLONNES];
+        boolean[] flatVerrous = new boolean[NB_LIGNES * NB_COLONNES];
+
+        for (int l = 0; l < NB_LIGNES; l++) {
+            for (int c = 0; c < NB_COLONNES; c++) {
+                flatGrille[l * NB_COLONNES + c] = grille[l][c];
+                flatVerrous[l * NB_COLONNES + c] = verrous[l][c];
+            }
+        }
+
+        bundle.putIntArray("grille", flatGrille);
+        bundle.putBooleanArray("verrous", flatVerrous);
+        bundle.putInt("score", score);
+        bundle.putInt("nbCoups", nbCoups);
+        bundle.putBoolean("partieTerminee", partieTerminee);
+    }
+
+    public void restaurerEtat(Bundle bundle) {
+        if (!bundle.containsKey("grille")) return;
+
+        int[] flatGrille = bundle.getIntArray("grille");
+        boolean[] flatVerrous = bundle.getBooleanArray("verrous");
+
+        if (flatGrille != null && flatVerrous != null) {
+            for (int l = 0; l < NB_LIGNES; l++) {
+                for (int c = 0; c < NB_COLONNES; c++) {
+                    grille[l][c] = flatGrille[l * NB_COLONNES + c];
+                    verrous[l][c] = flatVerrous[l * NB_COLONNES + c];
+                }
+            }
+        }
+
+        score = bundle.getInt("score");
+        nbCoups = bundle.getInt("nbCoups");
+        partieTerminee = bundle.getBoolean("partieTerminee");
+    }
+
     public int obtenirCase(int ligne, int colonne) {
         return grille[ligne][colonne];
     }
@@ -152,7 +195,8 @@ public class EtatJeu {
             return false;
         }
 
-        if (hardMode && estBloque(estLigne, index)) {
+        // Les verrous bloquent toujours, quel que soit le mode
+        if (estBloque(estLigne, index)) {
             return false;
         }
 
@@ -172,6 +216,8 @@ public class EtatJeu {
         nbCoups++;
         score += resoudreEtRemplir();
 
+        // Verrou après chaque coup ; 2 verrous en hard mode (plus difficile)
+        ajouterVerrou();
         if (hardMode) {
             ajouterVerrou();
         }
@@ -250,16 +296,16 @@ public class EtatJeu {
 
 
     public int resoudreEtRemplir() {
-        int pointsTotal = 0;
-        int vague       = 0;
+        int baseTotal = 0;
+        int nbSeries  = 0;
 
         List<int[]> series = trouverSeries();
 
         while (!series.isEmpty()) {
 
-            int pointsBase        = calculerPointsBase(series);
-            double multiplicateur = 1.0 + vague * 0.5;
-            pointsTotal           += (int) (pointsBase * multiplicateur);
+            // Accumuler les points de base et le nombre de séries sur toutes les vagues
+            baseTotal += calculerPointsBase(series);
+            nbSeries  += compterNbSeries(series);
 
             boolean[][] aSupprimer = new boolean[NB_LIGNES][NB_COLONNES];
 
@@ -293,11 +339,14 @@ public class EtatJeu {
                 }
             }
 
-            vague++;
             series = trouverSeries();
         }
 
-        return pointsTotal;
+        if (nbSeries == 0) return 0;
+
+        // Bonus : +50% par série supplémentaire après la première (spec SAÉ)
+        double bonus = 1.0 + (nbSeries - 1) * 0.5;
+        return (int) (baseTotal * bonus);
     }
 
     private int calculerPointsBase(List<int[]> series) {
@@ -350,6 +399,58 @@ public class EtatJeu {
         return total;
     }
 
+    private int compterNbSeries(List<int[]> series) {
+        boolean[][] masque = new boolean[NB_LIGNES][NB_COLONNES];
+
+        for (int[] pos : series) {
+            masque[pos[0]][pos[1]] = true;
+        }
+
+        int count = 0;
+
+        // Séries horizontales
+        for (int l = 0; l < NB_LIGNES; l++) {
+            int c = 0;
+
+            while (c < NB_COLONNES) {
+                if (masque[l][c]) {
+                    int fin = c + 1;
+
+                    while (fin < NB_COLONNES && masque[l][fin]) {
+                        fin++;
+                    }
+
+                    count++;
+                    c = fin;
+                } else {
+                    c++;
+                }
+            }
+        }
+
+        // Séries verticales
+        for (int col = 0; col < NB_COLONNES; col++) {
+            int l = 0;
+
+            while (l < NB_LIGNES) {
+                if (masque[l][col]) {
+                    int fin = l + 1;
+
+                    while (fin < NB_LIGNES && masque[fin][col]) {
+                        fin++;
+                    }
+
+                    count++;
+                    l = fin;
+                } else {
+                    l++;
+                }
+            }
+        }
+
+        return count;
+    }
+
     private int pointsPourLongueur(int longueur) {
         if (longueur == 3) {
             return 8;
@@ -424,27 +525,31 @@ public class EtatJeu {
 
 
     public boolean aUnCoupValide() {
+        // Teste tous les décalages possibles (1 à N-1) pour les lignes
         for (int i = 0; i < NB_LIGNES; i++) {
-            if (coupCreeSerie(true, i, +1)) {
-                return true;
-            }
-            if (coupCreeSerie(true, i, -1)) {
-                return true;
+            for (int s = 1; s < NB_COLONNES; s++) {
+                if (coupCreeSerie(true, i, s)) {
+                    return true;
+                }
             }
         }
 
+        // Teste tous les décalages possibles (1 à N-1) pour les colonnes
         for (int j = 0; j < NB_COLONNES; j++) {
-            if (coupCreeSerie(false, j, +1)) {
-                return true;
-            }
-            if (coupCreeSerie(false, j, -1)) {
-                return true;
+            for (int s = 1; s < NB_LIGNES; s++) {
+                if (coupCreeSerie(false, j, s)) {
+                    return true;
+                }
             }
         }
 
         return false;
     }
 
+    public void forcerFinDePartie() {
+        this.partieTerminee = true;
+    }
+
     private boolean coupCreeSerie(boolean estLigne, int index, int sens) {
         int[][] sauvegarde = copierGrille();