Plateau de jeu

La classe BoardUI du sous-paquetage gui, publique et finale, gère la partie de l'interface graphique qui représente le plateau de jeu.

Son constructeur est privé, la création d'une instance devant se faire au moyen d'une méthode fabrique nommée p. ex. create. Cette méthode est celle qui contient la quasi-totalité du code de cette étape, car son but est de construire l'interface graphique du plateau de jeu. Pour ce faire, elle prend les arguments suivants :

• la table associant les ancres à l'emplacement auquel elles correspondent, de type Map<TileLocation, Node>, et qui n'est rien d'autre que la table contenue dans l'enregistrement Tiles décrit à l'étape précédente,
• la valeur observable contenant l'état immuable (!) de la partie, de type ObservableValue<ImmutableGameState> — ObservableValue étant le type JavaFX des sujets d'observation, qui correspond au type Subject du patron Observer.

En plus de ces deux arguments, dont l'utilité devrait être claire, create en prend trois autres dont le seul but est de gérer le glisser/déposer des tuiles sur une destination. Ces arguments sont décrits ici dans un souci de cohérence, mais il est conseillé de les ignorer initialement, et de ne les ajouter que lorsque la partie « statique » de l'interface est terminée, et seule la partie dynamique manque encore. Il s'agit de :

• l'ensemble qui, lorsqu'un joueur humain sélectionne un groupe de tuiles d'une couleur donnée se trouvant sur une source donnée, contient tous les coups valides correspondants, de type Set<Move>,
• une valeur booléenne destinée à être mise à vrai si et seulement si les tuiles déplacées ont été lâchées sur une destination à même de les accueillir, de type boolean[] (voir ci-dessous pour une explication),
• une file bloquante destinée à contenir le coup joué par le joueur, de type BlockingQueue<Move>.

La raison pour laquelle la valeur booléenne est passée sous la forme d'un tableau — à un seul élément — est que c'est la manière la plus simple, en Java, de passer une valeur booléenne à une méthode dans le but qu'elle la modifie.

Il est important de comprendre que différentes parties du programme ont la responsabilité de modifier le contenu des trois valeurs susmentionnées :

• l'ensemble des coups est rempli par le composant gérant les tuiles — qui sera écrit à l'étape suivante — et les destinations ne font qu'examiner son contenu,
• la valeur booléenne est mise à vrai par la destination sur laquelle les tuiles ont été déposées, ssi cette destination est à même de les accueillir ; elle est ensuite consultée puis réinitialisée — c.-à-d. remise à faux — par le composant gérant les tuiles,
• le coup joué est placé dans la file bloquante par la destination sur laquelle les tuiles ont été déposées, ssi cette destination est à même de les accueillir ; une fois placé dans la file, le coup en sera par la suite extrait par la partie du programme gérant le jeu — qui sera le sujet de la dernière étape.

La méthode create crée la totalité du graphe de scène correspondant au plateau de jeu, et passe ensuite sa racine au constructeur (privé), qui la stocke dans un attribut de la classe. C'est cet attribut qui est retourné par la méthode root décrite ci-après.

En plus de cette méthode fabrique, BoardUI offre les méthodes suivantes :

• une méthode nommée p. ex. root, qui retourne le nœud JavaFX, de type Node, à la racine du graphe de scène représentant le plateau de jeu,
• une méthode nommée p. ex. showBonusPoints, qui prend en argument l'identité d'un joueur, de type PlayerId, et une « clef de bonus », de type Object, et qui rend visible les points bonus correspondants.

La « clef de bonus » passée à showBonusPoints peut être de trois types différents, en fonction de la catégorie des points bonus à afficher :

1. TileDestination.Pattern, qui signifie que les points bonus (+2) associés à cette ligne doivent être affichés,
2. Integer, qui signifie que les points bonus (+7) associés à cette colonne doivent être affichés,
3. TileKind.Colored, qui signifie que les points bonus (+10) associés à cette couleur doivent être affichés.

Voir les conseils de programmation plus bas pour comprendre comment écrire showBonusPoints.

Pour tester votre classe BoardUI, il ne sert à rien d'écrire des tests unitaires, car de manière générale le test unitaire d'interfaces graphiques est très difficile. Nous vous conseillons donc d'écrire plutôt une petite application JavaFX affichant le plateau de jeu dans une fenêtre, qui pourrait ressembler à ceci :

public final class TestBoardUI extends Application {
  @Override
  public void start(Stage primaryStage) {
    int playersCount = 2;
    Game game = new Game(PlayerId.ALL.stream()
      .map(pId ->
             new Game.PlayerDescription(pId, pId.name(), HUMAN))
      .limit(playersCount)
      .toList());
    ImmutableGameState initialGameState =
      ImmutableGameState.initial(game);

    ObservableValue<ImmutableGameState> gameStateP =
      new SimpleObjectProperty<>(initialGameState);
    Set<Move> potentialMoves = new HashSet<>();
    boolean[] moveAccepted = new boolean[]{false};
    BlockingQueue<Move> moveQueue = new SynchronousQueue<>();

    Tiles tiles = Tiles.create(game);
    BoardUI boardUI = BoardUI.create(tiles.anchors(),
                                     gameStateP,
                                     potentialMoves,
                                     moveAccepted,
                                     moveQueue);
    Parent root = new StackPane(boardUI.root());
    root.getStylesheets().add("ajul.css");

    primaryStage.setScene(new Scene(root));
    primaryStage.setTitle(TestBoardUI.class.getSimpleName());
    primaryStage.show();
  }
}

En l'exécutant, vous devriez voir une fenêtre similaire à celle de la figure 1 plus haut. Si vous constatez des différences au niveau de l'affichage, vous pouvez essayer d'ajouter temporairement les lignes suivantes à la feuille de style fournie (ajul.css) :

GridPane {
    -fx-grid-lines-visible: true
}

Cela a pour effet d'afficher des lignes entourant et séparant toutes les cases des panneaux de type GridPane, ce qui permet de visualiser leur structure. Vous devriez voir quelque chose de similaire à la figure 7 ci-dessous.