Alpha-renommages mineurs + début solveur sur unruly

main.scala

@@ -31,8 +31,8 @@ object CercleInvocation extends SimpleSwingApplication {
       private val but_moy = new RadioButton("Moyen")
       private val but_dur = new RadioButton("Difficile")
       private val but_per = new RadioButton("Personnalisé")
-      private val mutex = new ButtonGroup(but_fac, but_moy, but_dur, but_per)
-      mutex.select(but_fac)
+      private val group = new ButtonGroup(but_fac, but_moy, but_dur, but_per)
+      group.select(but_fac)
 
       // Boutons pour la sélection du jeu
       private val tt_dem = new RadioButton("Démineur")
@@ -50,7 +50,7 @@ object CercleInvocation extends SimpleSwingApplication {
             case 3 => jeu = new Unruly
             case 4 => jeu = new Flood
          }
-         mutex.selected.get match {
+         group.selected.get match {
             case `but_fac` => 
             case `but_moy` =>
                choix_de_jeu match {
@@ -204,7 +204,7 @@ object CercleInvocation extends SimpleSwingApplication {
                genere_a_parametre
             })
             contents += new Menu("Difficulté") {
-               contents ++= mutex.buttons
+               contents ++= group.buttons
             }
             contents += new MenuItem(Action("Sortir"){
                sys.exit(0)

unruly.scala

@@ -91,25 +91,29 @@ class Unruly extends Jeu[MonBouton] {
       var k = Random.nextBoolean
       var im = new ImageIcon
       var cl = Color.white
-      for (i <- 0 to borne) {
-         k = Random.nextBoolean
-         if (k) { 
-           im = new ImageIcon(getClass.getResource("blanc_inchangeable.png"))
-           cl = Color.white
-         }
-         else {
-           im = new ImageIcon(getClass.getResource("noir_inchangeable.png"))
-           cl = Color.black
-         }
-         while (boutons(x)(y).estColore || trois(x,y,cl)) {
-           x = Random.nextInt(tailleX)
-           y = Random.nextInt(tailleY)
-         }
-         boutons(x)(y).setColoration(true)
-         boutons(x)(y).setCouleur(cl)
-         boutons(x)(y).chgIconEtEnable(im, false)
-         nb_non_occupes = nb_non_occupes-1
-      }
+      var fini = false
+      while (!fini) {
+         for (i <- 0 to borne) {
+            k = Random.nextBoolean
+            if (k) { 
+              im = new ImageIcon(getClass.getResource("blanc_inchangeable.png"))
+              cl = Color.white
+            }
+            else {
+              im = new ImageIcon(getClass.getResource("noir_inchangeable.png"))
+              cl = Color.black
+            }
+            while (boutons(x)(y).estColore || trois(x,y,cl)) {
+              x = Random.nextInt(tailleX)
+              y = Random.nextInt(tailleY)
+            }
+            if (i == borne) { fini = solveur(x,y,cl) }
+            boutons(x)(y).setColoration(true)
+            boutons(x)(y).setCouleur(cl)
+            boutons(x)(y).chgIconEtEnable(im, false)
+            nb_non_occupes = nb_non_occupes-1
+         } 
+      }   
    }
 
    // Génératioàn aléatoire avec graine
@@ -158,7 +162,7 @@ class Unruly extends Jeu[MonBouton] {
          boutons(i)(j).desactive_couleur()
          nb_non_occupes += 1
       } else {
-         if (!trois(i,j,c) && nombre_aligne(i,true,c)<(tailleX/2) && nombre_aligne(j,false,c)<(tailleY/2)) {
+         if (!trois(i,j,c) && nombre_aligne(i,true,c)<(tailleY/2) && nombre_aligne(j,false,c)<(tailleX/2)) {
            boutons(i)(j).setCouleur(c)
            boutons(i)(j).active_couleur()
            nb_non_occupes -= 1
@@ -177,4 +181,105 @@ class Unruly extends Jeu[MonBouton] {
       theAction(i,j,Color.white)
       victoire()
    }
+
+   // Renvoie blanc si on donne noir, et réciproquement
+   def non_couleur(c: Color) = {
+      if (c == Color.black) { Color.white } else { Color.black }
+   }
+
+   // Solveur, détermine si une instance donnée admet une solution.
+   def solveur(x: Int, y: Int, c: Color) : Boolean = {
+      boutons(x)(y).setColoration(true)
+      boutons(x)(y).setCouleur(c)
+      nb_non_occupes -= 1
+      println("On compte : " + nb_non_occupes)
+      var result = false
+      if (trois(x,y,c)|| nombre_aligne(x,true,c) > (tailleY/2) ||
+      nombre_aligne(y,false,c) > (tailleX/2)) {
+         // Toujours revenir à l'état initial en sortie !
+         nb_non_occupes += 1
+         boutons(x)(y).setCouleur(Color.gray) 
+         boutons(x)(y).setColoration(false)
+         false 
+      } else if (victoire()) { 
+         // Toujours revenir à l'état initial en sortie !
+         nb_non_occupes += 1
+         boutons(x)(y).setCouleur(Color.gray) 
+         boutons(x)(y).setColoration(false)
+         true 
+      } else {
+         var i = 0
+         var j = 0
+         var solveur_lance = false
+         var res = false
+         while (i < tailleX && !solveur_lance) {
+         // Il suffit de lancer un seul solveur : s'il échoue, on aura une impossibilité
+         // immédiate puisque l'on ne teste ici que des cas où les règles imposent une
+         // unique possibilité.
+            if (boutons(i)(j).estColore) {
+               var col = boutons(i)(j).getCouleur
+               // Cas de deux cases contiguës horizontales.
+               if (boutons(i)(j+1).estColore(col)) { 
+                  if (j>0 && !boutons(i)(j-1).estColore) { // On essaie à gauche.
+                     res = solveur(i,j-1,non_couleur(col))
+                     solveur_lance = true
+                  } else if (j+1<tailleY-1 && !boutons(i)(j+2).estColore) { // On essaie à droite.
+                     res = solveur(i,j+2,non_couleur(col))
+                     solveur_lance = true
+                  }
+               }
+               // Cas de deux cases contiguës verticales.
+               if (!solveur_lance && i < tailleX-1 && boutons(i+1)(j).estColore(col)) { 
+                  if (i>0 && !boutons(i-1)(j).estColore) { // On essaie en haut.
+                     res = solveur(i-1,j,non_couleur(col))
+                     solveur_lance = true
+                  } else if (i+1<tailleX-1 && !boutons(i+2)(j).estColore) { // On essaie en bas.
+                     res = solveur(i+2,j,non_couleur(col))
+                     solveur_lance = true
+                  }
+               }
+               // Cas de deux cases séparées d'une autre horizontalement.
+               if (!solveur_lance && j+1 < tailleY-1 && boutons(i)(j+2).estColore(col)) { 
+                  if (!boutons(i)(j+1).estColore) { // On teste la case au milieu.
+                     res = solveur(i,j+1,non_couleur(col))
+                     solveur_lance = true
+                  }
+               }
+               // Cas de deux cases séparées d'une autre verticalment.
+               if (!solveur_lance && i+1 < tailleX-1 && boutons(i+2)(j).estColore(col)) {
+                  if (!boutons(i+1)(j).estColore) { // On teste la case au milieu.
+                     res = solveur(i+1,j,non_couleur(col))
+                     solveur_lance = true
+                  }
+               }
+               // Incrémentation : parcours des lignes une par une en testant toutes les colonnes.
+            }
+            if (j == tailleY-2) { j = 0 ; i = i+1 } else { j = j+1 }
+         }
+         if (res) { // Si un solveur lancé a renvoyé vrai, on s'arrête : le jeu est résoluble.
+            result = true
+         } else if (solveur_lance && !res) { // Si un solveur lancé a renvoyé faux, le jeu n'est pas résoluble.
+            result = false
+         } else if (!solveur_lance && !res) { // Sinon, on remplit une case au hasard.
+            i = 0
+            j = 0
+            while (i < tailleX && !res) {
+               if (!boutons(i)(j).estColore) {
+                  res = solveur(i,j,Color.black) // On essaie en noir.
+                  if (!res) { res = solveur(i,j,Color.white) } // Si ça n'a pas marché, en blanc.
+               }
+               if (!res) { // Si ça n'a toujours pas marché ou si la case était colorée, incrémentation.
+                  if (j == tailleY-1) { j = 0 ; i = i+1 } else { j = j+1 }
+               }
+            }
+            result = res
+         }
+         // Toujours revenir à l'état initial en sortie !
+         nb_non_occupes += 1
+         boutons(x)(y).setCouleur(Color.gray) 
+         boutons(x)(y).setColoration(false)
+         result
+      }
+   }
+
 }