//
//   Corrigé type
//   Ce code n'a pas été testé, il est tout a fait possible
//   qu'il y ait de petites erreurs syntaxiques
//

//
//      Exercice I
//
// Question 1.a
class Case {            // 10%
  Terrain     terrain;  // 10%
  List<Unite> unites;   // 20% (ArrayList ou LinkedList admis)
  Ville       ville;    // 10%

  Case() {              // constructeur 20%
    terrain = null;     // pas sanctionné
    ville = null;       // pas sanctionné
    unites = new ArrayList<Unite>(); // 30%
  }
}

// Question 1.b
// 0 ou 100%
void ajouteUnite(Unite unite) {
  unites.add(unite);
}

// Question 1.c
class Plateau {
  int      lignes;   // 5%
  int      colonnes; // 5%
  Case[][] grille;   // 10%
  
  Plateau(int lignes, int colonnes) {    // 20%
    this.lignes = lignes;                // 5%
    this.colonnes = colonnes;            // 5%
    grille = new Case[lignes][colonnes]; // 10%

    // double boucle: 30%
    for(int i=0; i<lignes; i++)
      for(int j=0; j<colonnes; j++)
        grille[i][j] = new Case();       // 10%
  }
}

// 
//     Exercice II
//
// Question 2.a
// 0 ou 100%
// il faut laisser la méthode peutEntrer abstraite car les contraintes
// de déplacements sont données dans les classes filles

// Question 2.b
// abstract class: 20%
abstract class Unite {
  // champs: 20%
  Joueur joueur;
  Image  image;
  
  // 20%
  Unite(Joueur joueur, Image image) {
    this.joueur = joueur;
    this.image = image;
  }

  // 20%
  void affiche(int x, int y) { image.affiche(x, y); }

  // 20%
  abstract boolean peutEntrer(Case case);
}

// Question 2.c
// extends: 20%
class Combattant extends Unite {
  // 20%
  Combattant(Joueur joueur, Image image) {
    super(joueur, image);
  }

  // 60% (30% si considère case.unites comme un tableau)
  boolean peutEntrer(Case case) {
    for(Unite u: case.unites)
      if(u instanceof Combattant)
        return false;
    return true;
  }
}

// 
//    Exercice III
//
// Question 3.a
void init() {
  // double boucle: 60% (autre solution: for(Case[] line: grille) for(Case cur: line) ... )
  for(int i=0; i<lignes; i++)
    for(int j= 0; j<colonnes; j++)
      grille[i][j].terrain = mer;    // initialisation correcte 40%
}

// Question 3.b
// signature: 10%
void construitContinent(Terrain terrain, int n) {
  int x;
  int y;

  // position initiale: 30%
  do {
    x = rand(lignes);
    y = rand(colonnes);
  } while(grille[x][y].terrain != mer);

  // boucle: 10%
  while(n > 0) {
    // changement terrain: 20%
    if(grille[x][y].terrain != terrain) {
      grille[x][y].terrain = terrain;
      n--;
    }

    // déplacement: 30%
    switch(rand(3)) {
      case 0: if(x > 0) x--; break;
      case 1: if(x < lignes - 1) x++; break;
      case 2: if(y > 0) y--; break;
      case 3: if(y < colonnes - 1) y++; break;
    }
  }
}

// Question 3.c
// 30%
class ContinentTropGrand extends Exception { }

// signature: 30%
void construitContinent(Terrain terrain, int n) throws ContinentTropGrand {
  // test: 20%
  // throw: 20%
  if(n > colonnes * lignes) throw new ContinentTropGrand();
}

//
//    Exercice 4
//
// Question 4.a
// 0 ou 100%
// Autre chose à la place de Plateau ou Plateau manquant : 50%
interface Contrainte {
  boolean initOk(Plateau plateau, int x, int y);
  boolean deplOk(Plateau plateau, int x, int y);
}

// Question 4.b
// implements: 30%
class ContraintesAutre implements Contrainte {
  // 70%
  boolean initOk(Plateau plateau, int x, int y) {
    return plateau.grille[x][y].terrain != mer;
  }

  // si il manque l'une des deux fonctions, on ne pénalise pas (une seule suffit pour avoir les points)
  boolean deplOk(Plateau plateau, int x, int y) {
    return initOk(plateau, x, y); 
  }
}

// Question 4.c
// nouvelle signature: 20%
void construitContinent(Contrainte contrainte, Terrain terrain, int n) throws ContinentTropGrand {
  int x;
  int y;

  // nouveau calcul position initiale: 30%
  do {
    x = rand(lignes);
    y = rand(colonnes);
  } while(!contrainte.initOk(this, x, y));

  while(n > 0) {
    if(grille[x][y].terrain != terrain) {
      grille[x][y].terrain = terrain;
      n--;
    }

    // nouveau déplacement: 50%
    switch(rand(3)) {
      case 0: if(x > 0 && contrainte.deplOk(x - 1, y)) x--; break;
      case 1: if(x < (lignes - 1) && contrainte.deplOk(x + 1, y)) x++; break;
      case 2: if(y > 0 && contrainte.deplOk(x, y - 1)) y--; break;
      case 3: if(x < (colonnes - 1) && contrainte.deplOk(x, y + 1)) y++; break;
    }
  }
}