Unruly est utilisable (le fichier test2 qui le lance n'est pas inclus)

boutons.scala

@@ -6,13 +6,13 @@ class MonBouton(protected var x : Int, protected var y : Int) extends Button {
     preferredSize = new Dimension(50, 50)
     borderPainted = true
     
+    def getTheX = x
+    def getTheY = y
+
+    // Gestion des éléments du Démineur
     private var contenu = 0 // 0-8 nbre mines, 9 mine
     private var libre = true //case sans rien
     private var drapeau = false
-
-
-    def getTheX = x
-    def getTheY = y
     
     def estLibre = libre
     def chgLibre = libre = !libre
@@ -30,21 +30,36 @@ class MonBouton(protected var x : Int, protected var y : Int) extends Button {
        libre = true
        drapeau = false
 
+    // Gestion des icones
+    def chgIconEtEnable(im: ImageIcon, en: Boolean) = {
+       icon = im
+       enabled = en
+       disabledIcon = im
+    }
+
     // Gestion de la couleur du bouton
-    private var couleur = Color.white
+    private var couleur = Color.gray 
     private var colore = false
 
     def estColore = colore
     def estColore(c: Color) = colore && (couleur == c)
-
+    
+    def setColoration(b: Boolean) = {
+       colore = b
+    }
     def setCouleur(c: Color) = {
        couleur = c
     }
 
-    def active_couleur = {
+    def active_couleur() = {
        background = couleur
        colore = true
-    }    
+    }
+    def desactive_couleur() = {
+       couleur = Color.gray
+       background = couleur
+       colore = false
+    }
 }
 
 

unruly.scala

 import scala.util.Random
 import Array._
 import java.awt.Color
+import javax.swing.ImageIcon
 
 class Unruly {
    // Cotés du terrain
    private var tailleX = 8
    private var tailleY = 8
 
+   private var nb_non_occupes = tailleX*tailleY
+
    def getTailleX = tailleX                                                      
    def getTailleY = tailleY                                                      
                                                                                  
@@ -22,35 +25,18 @@ class Unruly {
       boutons = ofDim[MonBouton](tailleX,tailleY)                                
    }                                                                             
                                                                                   
-   // Pour fixer la couleur d'un bouton.                                         
-   // Le champ "libre" de MonBouton permettra de représenter la couleur :        
-   // A true, la case est blanche ; à false elle est noire.                      
-   def fixCouleur(i: Int, j: Int) = {                                            
-      if (boutons(i)(j).estLibre) {                                              
-         boutons(i)(j).background = Color.white                                  
-      }                                                                          
-      else {                                                                     
-         boutons(i)(j).background = Color.black                                  
-      }                                                                          
-   } 
-
    // Fonction pour compter le nombre de cases noires ou blanches sur
    // une ligne ou une colonne. Le booléen lig indique si on regarde une
-   // ligne (true) ou une colonne (false), et blanc indique si on compte
-   // les cases blanches (true) ou noires (false).
-   def nombre_aligne(i: Int, lig: Boolean, blanc: Boolean) = {
+   // ligne (true) ou une colonne (false).
+   def nombre_aligne(i: Int, lig: Boolean, c: Color) = {
       var rep = 0
       if (lig) {
          for (j <- 0 to (tailleY-1)) {
-            if ((blanc && boutons(i)(j).estLibre) || (!blanc && !boutons(i)(j).estLibre)) {
-               rep = rep + 1
-            }
+            if (boutons(i)(j).estColore(c)) { rep = rep + 1 }
          }
       } else {
          for (j <- 0 to (tailleX-1)) {
-            if ((blanc && boutons(i)(j).estLibre) || (!blanc && !boutons(i)(j).estLibre)) {
-               rep = rep + 1
-            }
+            if (boutons(j)(i).estColore(c)) { rep = rep + 1 }
          }
       }
       rep
@@ -59,7 +45,27 @@ class Unruly {
    // Teste si trois cases consécutives sont colorées de la même manière 
    // lorsqu'on colorie une case Renvoie true si trois cases sont ainsi
    // detectées.
-   def trois(i: Int, j:Int, blanc: Boolean) = {
+   def trois(i: Int, j:Int, c: Color) = {
+      var res = false
+      if (i!=0 && i!=(tailleX-1)) {
+         res = res || (boutons(i-1)(j).estColore(c) && boutons(i+1)(j).estColore(c))
+      }
+      if (j!=0 && j!=(tailleY-1)) {
+         res = res || (boutons(i)(j-1).estColore(c) && boutons(i)(j+1).estColore(c))
+      }
+      if (i>1) {
+         res = res || (boutons(i-1)(j).estColore(c) && boutons(i-2)(j).estColore(c))
+      }
+      if (j>1) {
+         res = res || (boutons(i)(j-1).estColore(c) && boutons(i)(j-2).estColore(c))
+      }
+      if (i<(tailleX-2)) {
+         res = res || (boutons(i+1)(j).estColore(c) && boutons(i+2)(j).estColore(c))
+      }
+      if (j<(tailleY-2)) {
+         res = res || (boutons(i)(j+1).estColore(c) && boutons(i)(j+2).estColore(c))
+      }
+      res
    }
 
    // Génération d'une grille aléatoire
@@ -67,18 +73,33 @@ class Unruly {
       /* !!! */ for (i <- 0 to (tailleX-1)) {
          for (j <- 0 to (tailleY-1)) {
             boutons(i)(j) = new MonBouton(i,j)
+            boutons(i)(j).desactive_couleur
          }
       }
       var borne = (tailleX*tailleY)/4
-      var x = Random.nextInt
-      var y = Random.nextInt
+      var x = Random.nextInt(tailleX)
+      var y = Random.nextInt(tailleY)
       var k = Random.nextBoolean
+      var im = new ImageIcon
+      var cl = Color.white
       for (i <- 0 to borne) {
-         // setCouleurInchangeable(boutons(i,j)) ...
-         // while (déjà occupé x y faire
-         x = Random.nextInt
-         y = Random.nextInt
          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
       }
    }
 
@@ -87,27 +108,64 @@ class Unruly {
       /* !!! */ for (i <- 0 to (tailleX-1)) {
          for (j <- 0 to (tailleY-1)) {
             boutons(i)(j) = new MonBouton(i,j)
+            boutons(i)(j).desactive_couleur
          }
       }
       var borne = (tailleX*tailleY)/4
       var ran = new Random(n)
-      var x = ran.nextInt
-      var y = ran.nextInt
+      var x = ran.nextInt(tailleX)
+      var y = ran.nextInt(tailleY)
       var k = ran.nextBoolean
+      var im = new ImageIcon()
+      var cl = Color.white
       for (i <- 0 to borne) {
-         // setCouleurInchangeable(boutons(i,j)) ...
-         // while (déjà occupé x y) faire
-         x = ran.nextInt
-         y = ran.nextInt
-         k = ran.nextBoolean
+         k = ran.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 = ran.nextInt(tailleX)
+           y = ran.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
       }
    }
 
    // Test de victoire
-   def victoire = {
+   private def victoire = {
+      nb_non_occupes == 0
+   }
+
+   // Code de base d'une action
+   def theAction(i: Int, j: Int, c: Color) = {
+      if (boutons(i)(j).estColore) {
+         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)) {
+           boutons(i)(j).setCouleur(c)
+           boutons(i)(j).active_couleur()
+           nb_non_occupes -= 1
+         }
+      }
    }
-   
-   // Définition des conséquences d'un clic de souris
-   def clique_action(i: Int, j: Int) = {
+
+   // Définition des conséquences d'un clic gauche de souris
+   def clique_action_gauche(i: Int, j: Int) = {
+      theAction(i,j,Color.black)
+      victoire
+   }
+
+   // Définiton des conséquences d'un clic droit de souris
+   def clique_action_droit(i: Int, j: Int) = {
+      theAction(i,j,Color.white)
+      victoire
    }
 }