Exercice Java: Placement sans recouvrement - tableaux et modularisation

Facebook Tweet Pin Email

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

import java.util.Scanner;
class Recouvrement {
    private static Scanner scanner = new Scanner(System.in);
 
  public static void main(String[] args) {
    boolean [][] grille = new boolean [10][10];
    initGrille(grille);
    ajouterElements(grille);
    System.out.println("\nMerci d'avoir joué!");
  }
 
  /**
   * Essaie de remplir la grille avec un objet de longueur donnée
   * dans une direction donnée en partant des coordonnées 
   * (targetRow, targetCol). 
   * @param grille
   * @param targetRow
   * @param targetCol
   * @param direction
   * @param longueur
   * @return true si le placement est réussi et false sinon
   */
  static boolean remplitGrille(boolean [][] grille, int targetRow, 
                   int targetCol, char direction, 
                   int longueur) {
 
    int deltaRow = 0, deltaCol = 0;
    int dim = grille.length;
 
    // On calcule ici la direction dans laquelle aller depuis 
    // les coordonnées indiquées par l'utilisateur.
    // Ex: pour aller au nord, il faut monter d'une 
    // ligne en restant sur la
    // même colonne.
    switch (direction) {
    case 'N':
      deltaRow = -1;
      deltaCol = 0;
      break;
    case 'S':
      deltaRow = 1;
      deltaCol = 0;
      break;
    case 'E':
      deltaRow = 0;
      deltaCol = 1;
      break;
    case 'O':
      deltaRow = 0;
      deltaCol = -1;
      break;
    }
 
    // On se place sur la case de départ
    int tempRow = targetRow;
    int tempCol = targetCol;
 
    // Est-il possible de placer l'élément ?
    boolean possible = true;
 
    // Avant de modifier la grille il faut vérifier s'il est 
    // possible de mettre tout l'objet
    for (int i = 0; (i < longueur && possible); i++) {
      if ((tempRow < 0) || (tempRow >= dim)) {
        possible = false;
      }
      else if ((tempCol < 0) || (tempCol >= dim)) {
    possible = false;
      } else  if (grille [tempRow][tempCol]) {
        possible = false;
      }
 
      // On se déplace sur la case suivante
      tempRow += deltaRow;
      tempCol += deltaCol;
    }
 
    // Le placement est possible, et on peut donc mettre
    // à jour la grille
    if (possible) {
      tempRow = targetRow;
      tempCol = targetCol;
 
      for (int i = 0; i < longueur; i++) {
        grille [tempRow][tempCol] = true;
        tempRow += deltaRow;
        tempCol += deltaCol;
      }
    }
 
    return possible;
  }
 
  /**
   * Initialise toutes les cases de la grille à false
   * @param grille
   */
  static void initGrille(boolean[][] grille) {
    int dim = grille.length;
    for (int row = 0; row < dim; row++) {
      for (int col = 0; col < dim; col++) {
        grille[row][col] = false;
      }
    }
  }
 
  /**
   * Permet à l'utilisateur de demander le placement d'objets
   * sur la grille.
   * @param grille
   */
  static void ajouterElements(boolean[][] grille) {
    int col, row;
    char dir;
    int length;
    System.out.print("Entrez la taille  " +
             "(négative pour arrêter le programme): ");
    length = scanner.nextInt();
    // L'utilisateur signifie qu'il veut arrêter 
    // d'introduire des objets en spécifiant une 
    //longueur négative
    while (length >= 0) {
      do {
        System.out.print("Entrez coord. x : ");
        col = scanner.nextInt();
      } while ((col < 0) || (col >= grille.length));
 
      do {
        System.out.print("Entrez coord. y : ");
        row = scanner.nextInt();
      } while ((row < 0) ||(row >= grille.length));
 
      do {
        System.out.print("Entrez direction (N,S,E,O) : ");
        dir = scanner.next().charAt(0);
      } while ((dir != 'N') && (dir != 'S') && (dir != 'E') && (dir != 'O'));
 
      System.out.print("Placement en (" + col + "," + row + ") direction "
               + dir + " longueur " + length + " -> ");
 
      if (remplitGrille(grille, col, row, dir, length)) {
        System.out.println("Succès");
        afficheGrille(grille);
      } else {
        System.out.println("Echec");
      }
      System.out.println(); 
      System.out.print("Entrez la taille " +
               "(négative pour arrêter le programme): ");
      length = scanner.nextInt();
 
    }
  }
 
  /**
   * Affichage de la grille
   * @param grille
   */
  static void afficheGrille(boolean[][] grille) {
    int dim = grille.length;
    for (int row = 0; row < dim; row++) {
      for (int col = 0; col < dim; col++) {
        if (grille[row][col])
          System.out.print("#");
        else
          System.out.print(".");
      }
      System.out.println();
    }
  }
}