Teaching - 2i002 - (TME: sujets)


2i002 : Introduction à la programmation Objet

Jeu des sorcières

le but est de résoudre le casse-tête automatiquement en utilisant une modélisation propre. Le site web est là pour simplifier les copier-coller de code.

Jeu des sorcières: il faut bouger et effectuer des rotations sur les 9 pièces pour que toutes les sorcières soient cohérentes (têtes et derrières de la même couleur, pas de double tête/double derrière). Note: dans l'agencement proposé ci-dessous, rien n'est compatible, il s'agit d'une des pires proposition possible!

Classe Piece

La première étape consiste à coder les pièces pour:

  • pouvoir facilement faire des rotations,
  • facilement tester si la pièce d'à coté est compatible

Proposition de codage pour chaque demi-sorcière:

Chaque demi-sorcière sera codée par un entier, nous ferons en sorte qu'une bonne sorcière somme à 9 tandis que toutes les mauvaises combinaisons donnent une somme différente de 9

  • Rouge tête = 1 derrière = 8
  • Jaune tête = 2 derrière = 7
  • Vert tête = 3 derrière = 6
  • Violet tête = 4 derrière = 5

Gestion de la rotation

Solution pour le codage de la pièce:

 public class Piece {
   private int[] cotes;
   private int iRotation;

   public Piece(int g, int h, int d, int b){
       cotes = new int[]{g,h,d,b}; // syntaxe rapide
       iRotation = 0;
   }

   public void rotation(){ // 90° sens horaire
       iRotation ++;
   }

   public int getG(){return cotes[(0+iRotation)%4];}
   public int getH(){return cotes[(1+iRotation)%4];}
   public int getD(){return cotes[(2+iRotation)%4];}
   public int getB(){return cotes[(3+iRotation)%4];}
   // toujours penser à l'affichage pour le debbuggage
   public String toString(){ // utilisation des sous-fonctions
       return " "+getH()+" "+"\n"+ getG()+" "+
          getD()+"\n"+ " "+getB()+" ";
   }
 }

Code de la classe de test:

public class TestPiece {
    public static void main(String[] args) {
        Piece p = new Piece(7,8,3,4);
        System.out.println(p.toString());

        for(int i=0; i<4; i++){
            p.rotation();
            System.out.println(p.toString());
        }
    }
}

Classe PlateauJeu

La classe PlateauJeu doit permettre de gérer facilement les 9 pièces constituant le jeu. Elle devra donc permettre de bouger les pièces et compter les erreurs (i.e. les incompatibilités avérées entre demi-sorcières). L'énoncé ci-dessous décrit le fonctionnement de cette classe.

  • attribut Piece[] plateau
  • Constructeur à 9 arguments (ou tableau au choix)
  • Comptage des erreurs
    • 12 tests à effectuer (seules les sorcières à la jointure entre 2 cartes sont comptabilisées)
    • Si la carte1 est à gauche de la carte2, l'erreur est mesurée par
int cptErr = 0;
nbErr+=(carte1.getD()+ carte2.getG()==9) ? 0:1;
... // 12 fois

ATTENTION: ce code est à comprendre et à adapter, pas à recopier

  • Disposition aléatoire
    • Faire 9 échanges aléatoires de cartes + rotations aléatoires
   Note:
   Pour tirer facilement un entier entre 0 (inclus) et 9 (exclus):
    import java.util.Random;
    Construire & instancier un attribut private Random r dans la classe
    Appeler r.nextInt(9);
  • Rotation d'une pièce
  • Fonction d'affichage (obligatoire pour les tests) ! L'affichage pourra prendre la forme suivante:
   6   8   3
  1+7 3+5 5+4
   4   4   8

   8   7   7
  7+3 6+3 5+3
   4   1   1

   2   8   4
  4+5 2+7 8+2
   8   3   6

Note: avec les accesseurs getH, ... cette fonction est assez fastidieuse à écrire Code de création du jeu (pour avoir les bonnes pièces)!

Code pour créer le jeu dans le main:

Piece[] tab = new Piece[]{ new Piece(1,6,7,4), new Piece(3,8,5,4), new Piece(5,3,4,8),
                new Piece(7,8,3,4),new Piece(6,7,3,1),new Piece(5,7,3,1),
                new Piece(4,2,5,8),new Piece(2,8,7,3),new Piece(8,4,2,6)};
Jeu j = new Jeu(tab);

Classe Solveur

Pour avoir un code plus propre, nous proposons de gérer l'optimisation dans une classe à part. Le Solveur contient donc un plateau de jeu et propose de chercher une solution en cherchant plein de combinaison (on parle de calcul intensif, ou de solution bête et méchante...).

Classe Solveur

  • Attribut: PlateauJeu j
  • Méthode: Jeu resoudre()
   Proposition d'algo:
    Tant qu'il y a des erreurs
     Melanger le jeu
     Faire défiler les 9 cartes dans le désordre et pour chaque carte
       Tester les 4 rotations possibles
       Conserver la configuration minimisant les erreurs
     [OPT] Sauvegarder le Jeu s'il est meilleur que la sauvegarde précédente 
      (cette fonctionnalité requiert un clonage non-trivial)