Je dois recréer le désert interdit en java voici mon code : /**
 * Application avec interface graphique.
 * Thibaut Balabonski, Université Paris-Sud.
 * Matériel pédagogique lié au cours POGL,
 * 
 * Un principe directeur est la séparation stricte des deux parties suivantes :
 *  - Le coeur de l'application, appelé le modèle, où est fait l'essentiel
 *    du travail.
 *  - L'interface utilisateur, appelée la vue, qui à la fois montre des choses
 *    à l'utilisateur et lui fournit des moyens d'interagir.
 *
 * Notre cas d'étude : le Plateau de la vie de Conway.
 * Une grille bidimensionnelle de dimensions finies est peuplée de plat
 * pouvant être vivantes ou mortes. À chaque tour un nouvel état est calculé
 * pour chaque Case en fonction de l'état de ses voisines immédiates.
 * Un bouton permet de passer au tour suivant (on dit aussi la génération
 * suivante).
 */

/**
 * Un lien entre vue et modèle : les informations montrées à l'utilisateur
 * reflètent l'état du modèle et doivent être maintenues à jour.
 * 
 * Pour réaliser cette synchronisation, on peut suivre le schéma de conception
 * observateur/observé, dont le principe est le suivant :
 *  - Un observateur (en l'occurrence la vue) est lié à un objet observé et se
 *    met à jour pour refléter les changement de l'observé.
 *  - Un observé est lié à un ensemble d'objets observateurs et les notifie de
 *    tout changement de son propre état.
 *
 * Java fournit une interface [Observer] (observateur) et une classe
 * [Observable] (observé) assurant cette jonction.
 * Voici une manière sommaire de les recoder.
 */

/**
 * Interface des objets observateurs.
 */ 
interface Observer {
    /**
     * Un observateur doit posséder une méthode [update] déclenchant la mise à
     * jour.
     */
    public void update();
    /**
     * La version officielle de Java possède des paramètres précisant le
     * changement qui a eu lieu.
     */
}

/**
 * Classe des objets pouvant être observés.
 */
abstract class Observable {
    /**
     * On a une liste [observers] d'observateurs, initialement vide, à laquelle
     * viennent s'inscrire les observateurs via la méthode [addObserver].
     */
    private ArrayList<Observer> observers;
    public Observable() {
	this.observers = new ArrayList<Observer>();
    }
    public void addObserver(Observer o) {
	observers.add(o);
    }

    /**
     * Lorsque l'état de l'objet observé change, il est convenu d'appeler la
     * méthode [notifyObservers] pour prévenir l'ensemble des observateurs
     * enregistrés.
     * On le fait ici concrètement en appelant la méthode [update] de chaque
     * observateur.
     */
    public void notifyObservers() {
	for(Observer o : observers) {
	    o.update();
	}
    }
}
/** Fin du schéma observateur/observé. */


/**
 * Nous allons commencer à construire notre application, en voici la classe
 * principale.
 */
public class Game{
    /**
     * L'amorçage est fait en créant le modèle et la vue, par un simple appel
     * à chaque constructeur.
     * Ici, le modèle est créé indépendamment (il s'agit d'une partie autonome
     * de l'application), et la vue prend le modèle comme paramètre (son
     * objectif est de faire le lien entre modèle et utilisateur).
     */
    public static void main(String[] args) {
	/**
	 * Pour les besoins du jour on considère la ligne EvenQueue... comme une
	 * incantation qu'on pourra expliquer plus tard.
	 */
	EventQueue.invokeLater(() -> {
		/** Voici le contenu qui nous intéresse. */
                Plateau modele = new Plateau();
                CVue vue = new CVue(modele);
	    });
    }
}
/** Fin de la classe principale. */


/**
 * Le modèle : le coeur de l'application.
 *
 * Le modèle étend la classe [Observable] : il va posséder un certain nombre
 * d'observateurs (ici, un : la partie de la vue responsable de l'affichage)
 * et devra les prévenir avec [notifyObservers] lors des modifications.
 * Voir la méthode [avance()] pour cela.
 */
class Plateau extends Observable {

    private Case[][] plat;

    int Oui, Ouj;

    /** Construction : on initialise un tableau de plat. */
    public Plateau() {
	/**
	 * Pour éviter les problèmes aux bords, on ajoute une ligne et une
	 * colonne de chaque côté, dont les plat n'évolueront pas.
	 */ 
        plat = new Case[5][5];
        for(int i=0; i<5; i++) {
            for(int j=0; j<5; j++) {
            plat[i][j] = new Case();
	        }
	    }
    }

    /**
     * Initialisation aléatoire des plat, exceptées celle des bords qui
     * ont été ajoutés.
     */
    public int qteSable(){
        int qte = 0;
        for (int i = 0; i<5; i++){
            for (int j = 0; j<5; j++){
                qte += plat[i][j].tsable;
            }
        }
        return qte;
    }

    public float puissanceO(int Oi, int Oj){
        oeuil o = (oeuil) plat[Oi][Oj];
        return o.puissance;
    }

    public boolean partieFinie(int Oi, int Oj){
        return (this.qteSable()>= 43) || (this.puissanceO(Oi, Oj)>=7);
    }

    public void TDechaine(int Oi, int Oj){
        float incr = 1/2;
        oeuil o = (oeuil) plat[Oi][Oj];
        o.addPuissance(incr);
    }

    public void souffle(int Oi, int Oj){
		int puiss = (int)(Math.random() * ((3 - 1) + 1)) + 1;
        int dir = (int)(Math.random() * (4 + 1));
        oeuil o = (oeuil) plat[Oi][Oj];
        o.addPuissance((float) puiss);
        switch(dir){
            case 0: 
            if(Oi > 0){ // Verifiee si on peut déplacer la case vers le haut
                Case temp = plat[Oi][Oj];
                plat[Oi][Oj] = plat[Oi-1][Oj];
                plat[Oi-1][Oj] = temp;
                this.Oui = Oi-1;}
                // Est-ce qu'il faut ajouter break; ici ? comme ça, on évite de continuer à executer les autres cas :o
            case 1:
            if(Oj < this.plat[0].length - 1){ // Verifie  si on peut déplacer la case vers la droite
                Case temp1 = plat[Oi][Oj];
                plat[Oi][Oj] = plat[Oi][Oj+1];
                plat[Oi][Oj+1] = temp1;
                this.Ouj = Oj-1;}
                //break;
            case 2:
            if(Oi < this.plat.length - 1){ // Vérifier si on peut déplacer la case vers le ba
                Case temp2 = plat[Oi][Oj];
                plat[Oi][Oj] = plat[Oi+1][Oj];
                plat[Oi+1][Oj] = temp2;
                this.Oui = Oi+1;}
                //break;
            case 3:
                Case temp3 = plat[Oi][Oj];
                plat[Oi][Oj] = plat[Oi][Oj-1];
                plat[Oi][Oj-1] = temp3;
        }
    }

    public void finDeTour(int Oi, int Oj) {
        int quoi = (int)(Math.random() * (1 + 1));
        if (quoi == 0){
            this.souffle(Oi, Oj);
        }
        else{
            this.TDechaine(Oi, Oj);
        }
	    notifyObservers();
    }

    /**
     * Une méthode pour renvoyer la Case aux coordonnées choisies (sera
     * utilisée par la vue).
     */
    public Case getCase(int x, int y) {
	return plat[x][y];
    }
    /**
     * Notez qu'à l'intérieur de la classe [plateau], la classe interne est
     * connue sous le nom abrégé [Case].
     * Son nom complet est [plateau.Case], et cette version complète est
     * la seule à pouvoir être utilisée depuis l'extérieur de [plateau].
     * Dans [plateau], les deux fonctionnent.
     */
}

/** Fin de la classe plateau. */