abstraction Jeu

boum.scala

@@ -3,10 +3,10 @@ import Array._
 import javax.swing.ImageIcon
 import scala.math._
 
-class Demineur {
+class Demineur extends Jeu[MonBouton] {
    // Taille du champ de mine. Par défaut, réglé en "Facile".
-   private var tailleX = 9
-   private var tailleY = 9
+   tailleX = 9
+   tailleY = 9
 
    // Propage le clic pour le premier coup après non
    private var premierCoup = true
@@ -18,11 +18,12 @@ class Demineur {
    private var m_trouvees = 0
    
    // Compteur du nombre de cases restantes.
-   private var c_restantes = tailleX*tailleY - nb_mines
+   private var c_restantes = {tailleX*tailleY - nb_mines}
+   
    
 
    // Détermine si on a gagné.
-   def victoire : Boolean = (nb_mines == m_trouvees) || c_restantes == 0
+   def victoire() = {(nb_mines == m_trouvees) || c_restantes == 0}
 
    // Matrice représentant le champ de mines. Ses valeurs sont comprises entre 0 et 9.
    // 0-8 : Nombre de mines autour de la case vide.
@@ -31,7 +32,7 @@ class Demineur {
 //   private var champ = ofDim[Int](tailleX,tailleY)
    
    // Matrice des boutons associés aux cases (il me semble plus pertinent de l'inclure dans le jeu).
-   var boutons = ofDim[MonBouton](tailleX,tailleY)
+   protected var boutons = ofDim[MonBouton](tailleX,tailleY)
    
    // Réinitialise les paramètres ci-dessus en cas de changement de difficulté.
    def reparametrage (x: Int, y: Int, n: Int) = {
@@ -52,14 +53,10 @@ class Demineur {
    
    // Réactive la variable de premier coup
    def resetPremierCoup = premierCoup = true
- 
+   
    // (Re)crée un champ de boutons sans toucher aux valeurs
    def creation_boutons = {
-      for (i <- 0 to (tailleX-1)) {
-         for (j <- 0 to (tailleY-1)) {
-            boutons(i)(j) = new MonBouton(i,j)
-         }
-      }
+      map_init((i,j) => new MonBouton(i,j), boutons)
    }
 
    // Initialisation basique d'un champ de mine.

jeu.scala

+import scala.util.Random
+import swing._
+import Array._
+import javax.swing.ImageIcon
+import scala.math._
+
+abstract class Jeu[T<:Button] {
+   
+   protected var tailleX : Int = 9
+   protected var tailleY : Int = 9
+   protected var boutons : Array[Array[T]]
+   
+   protected def map_init(f : (Int,Int) => T, a : Array[Array[T]]) = {
+      for (i <- 0 to (tailleX-1))
+         for (j <- 0 to (tailleY-1))
+            a(i)(j) = f(i,j)
+   }
+   
+   protected def map_apply(f : T => Unit, a : Array[Array[T]]) = {
+      a.map(x => x.map(f))
+   }
+   
+   def victoire() : Boolean
+}