FFboardFiller.java

package model.firefighter;

import model.BoardData;
import model.elementTokens.ConnexElement;
import model.Element;
import util.Position;
import view.ViewElement;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * Classe responsable du remplissage du plateau de jeu avec les éléments spécifiés.
 * <p>
 * Cette classe gère le placement des éléments du jeu sur le plateau en fonction du nombre d'éléments à placer
 * (indiqué par le tableau {@code counter}). Chaque élément est instancié à une position aléatoire parmi les
 * positions disponibles. Certains éléments, comme ceux de type {@link ConnexElement}, influencent les positions
 * où d'autres éléments peuvent être placés.
 * </p>
 */
public class FFboardFiller {

    /** Objet pour générer des positions aléatoires. */
    private Random random = new Random();

    /**
     * Remplie le plateau de jeu avec les éléments spécifiés dans {@code counter}.
     * <p>
     * Cette méthode parcourt les éléments définis dans {@link ViewElement}, instancie chaque élément à une position
     * aléatoire parmi les positions disponibles sur le plateau, et les place sur le plateau en utilisant la méthode
     * {@link BoardData#addElement(Element)}.
     * </p>
     * <p>
     * Le tableau {@code counter} spécifie le nombre d'éléments de chaque type à placer. Après chaque placement,
     * le compteur correspondant est décrémenté.
     * </p>
     *
     * @param boardData L'état actuel du plateau de jeu utilisé pour ajouter les éléments.
     * @param counter   Tableau représentant le nombre d'éléments à placer pour chaque type d'élément (indexé par {@link ViewElement#ordinal()} ou :
     *             //roads
     *             //forests
     *             //rocks
     *             //mountains
     *             //firefighter
     *             //motorized firefighter
     *             //motorized firefighter (AKA superman)
     *             //clouds
     *             //fires
     */
    public void fillBoard(BoardData boardData, int[] counter) {
        List<Position> positions = new ArrayList<>(List.copyOf(boardData.getNeighbors().keySet()));

        // Parcours de chaque élément possible dans l'énumération ViewElement
        for (ViewElement ve : ViewElement.values()) {
            // On ne place pas d'élément de type EMPTY
            if (ve != ViewElement.EMPTY) {
                // Tant qu'il y a des éléments à placer pour ce type
                while (counter[ve.ordinal()] > 0) {
                    Element element;
                    Position p;
                    do {
                        // Choisit une position aléatoire parmi les positions disponibles
                        p = positions.get(random.nextInt(positions.size()));
                        // Crée l'élément correspondant à la position choisie
                        element = ve.instanciate(boardData, p);
                    } while (!boardData.addElement(element)); // Réessaye si la position est invalide

                    // Si l'élément est un ConnexElement, retire les positions occupées par ses voisins
                    if (element instanceof ConnexElement) {
                        positions.removeAll(boardData.getElements().get(element.getType().ordinal()).stream()
                                .map(x -> x.getPosition())
                                .toList());
                    }

                    // Retire la position utilisée
                    positions.remove(p);

                    // Décrémente le compteur pour ce type d'élément
                    counter[ve.ordinal()]--;
                }
            }
        }
    }
}