Compare revisions

## Description du projet 

Le [jeu de la vie](https://fr.wikipedia.org/wiki/Jeu_de_la_vie) n’est pas vraiment un jeu, puisqu'il ne nécessite aucun joueur.

Le [jeu de la vie](https://fr.wikipedia.org/wiki/Jeu_de_la_vie) est une implémentation d'un 

modèle de calcul : les automates cellulaires.

Le jeu se déroule sur une grille à deux dimensions dont les cases qu’on appelle des cellules peuvent prendre deux états distincts : vivantes ou mortes.

Le modèle se présente sous la forme d'une grille à deux dimensions dont les cases, qu’on 

appelle des cellules, peuvent prendre deux états distincts : vivantes ou mortes.

À chaque étape, l’évolution d’une cellule est entièrement déterminée par l’état de ses huit voisines de la façon suivante :

À chaque étape, de calcul, l'état de chaque cellule est recalculé. Le nouvel état d'une cellule 

est entièrement déterminée par l’état de ses huit voisines de la façon suivante :

- Une cellule morte possédant exactement trois voisines vivantes devient vivante (elle naît).

- Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle meurt.

- Une cellule morte possédant exactement trois voisines vivantes devient vivante.

- Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle devient morte.

Le but de ce TP est de compléter le code fourni par le dépôt afin d'obtenir un simulateur de jeu de la vie.

Le but de ce TP est de compléter le programme fourni par le dépôt afin d'obtenir un simulateur de 

jeu de la vie.

## Membre du projet

}

javafx {

    version = "20"

    version = "22"

    modules = [ 'javafx.controls', 'javafx.fxml' ]

}

}

application {

    mainClassName = "GameOfLifeApplication"

    mainClassName = "SimulatorApplication"

}

 No newline at end of file

distributionBase=GRADLE_USER_HOME

distributionPath=wrapper/dists

distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip

distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip

zipStoreBase=GRADLE_USER_HOME

zipStorePath=wrapper/dists

import controller.Controller;

import controller.Simulation;

import javafx.application.Application;

import javafx.application.Platform;

import javafx.fxml.FXMLLoader;

import javafx.scene.Parent;

import javafx.scene.Scene;

import javafx.stage.Stage;

import model.GameOfLife;

import model.Grid;

import model.CellularAutomatonSimulation;

import model.automata.GameOfLifeAutomaton;

import java.io.IOException;

import java.net.URL;

import static java.util.Objects.requireNonNull;

import java.util.Random;

/**

 * Entry point for <i>The Game of Life</i> application.

 *

 */

public class GameOfLifeApplication extends Application {

public class SimulatorApplication extends Application {

  public static final int NUMBER_OF_ROWS = 40;

  public static final int NUMBER_OF_COLUMNS = 70;

  private static final int NUMBER_OF_ROWS = 40;

  private static final int NUMBER_OF_COLUMNS = 70;

  public static final Random GENERATOR = new Random();

  private static final String APP_NAME = "Game of Life";

  private static final String APP_NAME = "2D Cellular automata";

  private static final String VIEW_RESOURCE_PATH = "/view/view.fxml";

  private final GameOfLife gameOfLife;

  private final Simulation simulation;

  private Stage primaryStage;

  private Parent view;

  /**

   * Creates a new {@code GameOfLifeApplication} instance.

   */

  public GameOfLifeApplication() {

    this(new GameOfLife(new Grid(NUMBER_OF_ROWS, NUMBER_OF_COLUMNS)));

  public SimulatorApplication() {

    this.simulation =

      new CellularAutomatonSimulation<>(

              new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),

              GENERATOR

      );

  }

  /**

   * Creates a new {@code GameOfLifeApplication} instance given a {@link GameOfLife} instance.

   *

   * @param gameOfLife the {@link GameOfLife} instance

   * @throws NullPointerException if {@code gameOfLife} is {@code null}

   */

  private GameOfLifeApplication(GameOfLife gameOfLife) {

    this.gameOfLife = requireNonNull(gameOfLife, "game of life is null");

  }

  @Override

  public void start(Stage primaryStage) throws IOException {

  private void initializeView() throws IOException {

    FXMLLoader loader = new FXMLLoader();

    URL location = GameOfLifeApplication.class.getResource(VIEW_RESOURCE_PATH);

    URL location = SimulatorApplication.class.getResource(VIEW_RESOURCE_PATH);

    loader.setLocation(location);

    view = loader.load();

    Controller controller = loader.getController();

    controller.setGameOfLife(gameOfLife);

    controller.setSimulation(simulation);

  }

package controller;

import matrix.Coordinate;

import javafx.animation.Animation;

import javafx.animation.KeyFrame;

import javafx.animation.Timeline;

import javafx.event.ActionEvent;

import javafx.event.EventHandler;

import javafx.fxml.FXML;

import javafx.scene.control.Label;

import javafx.scene.control.ToggleButton;

import javafx.scene.control.ToggleGroup;

import model.GameOfLife;

import model.Grid;

import javafx.util.Duration;

import view.MatrixPane;

import static java.util.Objects.requireNonNull;

 */

public class Controller {

    public static final int PERIOD_IN_MILLISECONDS = 100;

    @FXML

    private ToggleButton playToggleButton;

    @FXML

    private Label generationNumberLabel;

    @FXML

    private MatrixPane matrixPane;

    private Timeline timeline;

    private GameOfLife gameOfLife;

    public Simulation getSimulation() {

        return simulation;

    }

    private Simulation simulation;

    @FXML

    private void initialize() {

        initializePlayAndPauseToggleButtons();

        updateTimeline();

    }

    private void initializePlayAndPauseToggleButtons() {

    }

    /**

     * Sets {@link GameOfLife} instance.

     *

     * @param gameOfLife {@link GameOfLife} instance

     * @throws NullPointerException if {@code gameOfLife} is {@code null}

     */

    public void setGameOfLife(GameOfLife gameOfLife) {

        this.gameOfLife = requireNonNull(gameOfLife, "game of life is null");

    public void setSimulation(Simulation simulation) {

        this.simulation = requireNonNull(simulation, "game of life is null");

        setGenerationNumberLabelTextProperty();

        initializeMatrixPane();

    }

    private void setGenerationNumberLabelTextProperty() {

        generationNumberLabel.textProperty().bind(gameOfLife.generationNumberProperty().asString());

        updateGenerationNumber(0);

        this.simulation.setGenerationNumberChangeListener(

                (oldValue, newValue) -> updateGenerationNumber(newValue)

        );

    }

    private void updateGenerationNumber(int newValue) {

        generationNumberLabel.textProperty().set(String.valueOf(newValue));

    }

    private void initializeMatrixPane() {

        Grid grid = gameOfLife.getGrid();

        matrixPane.initialize(grid);

        matrixPane.initialize(this);

    }

    @FXML

    private void playToggleButtonAction() {

        gameOfLife.play();

        this.play();

    }

    @FXML

    private void pauseToggleButtonAction() {

        gameOfLife.pause();

        this.pause();

    }

    @FXML

    private void resetButtonAction() {

        gameOfLife.reset();

        this.pause();

        simulation.reset();

        pauseToggleButton.setSelected(true);

    }

    @FXML

    private void clearButtonAction() {

        gameOfLife.clear();

        this.pause();

        simulation.clear();

        pauseToggleButton.setSelected(true);

    }

    public Iterable<Coordinate> coordinates() {

        return simulation;

    }

    private void updateTimeline() {

        Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);

        EventHandler<ActionEvent> eventHandler =

                event -> simulation.updateToNextGeneration();

        KeyFrame keyFrame = new KeyFrame(duration, eventHandler);

        timeline = new Timeline(keyFrame);

        timeline.setCycleCount(Animation.INDEFINITE);

    }

    /**

     * Plays the game.

     */

    public void play() {

        timeline.play();

    }

    /**

     * Pauses the game.

     */

    public void pause() {

        timeline.pause();

    }

}

package controller;

import matrix.Coordinate;

import javafx.scene.paint.Color;

import model.OnChangeListener;

/**

 * Represents a simulation of a 2D cellular automaton, such as the Game of Life.

 * Provides methods for updating the simulation, retrieving information, and managing listeners.

 */

public interface Simulation extends Iterable<Coordinate> {

    /**

     * Returns the number of columns in the simulation grid.

     *

     * @return The number of columns in the grid.

     */

    int numberOfColumns();

    /**

     * Returns the number of rows in the simulation grid.

     *

     * @return The number of rows in the grid.

     */

    int numberOfRows();

    /**

     * Updates the simulation to the next generation. This is done by computing, for each

     * coordinate, a new state that depends on the states of its neighbours.

     */

    void updateToNextGeneration();

    /**

     * Changes the state at a given {@link Coordinate}. This is used to edit the grid with the mouse. It

     * is not part of the simulation of the cellular automaton.

     *

     * @param coordinate The {@link Coordinate} to advance to the next state.

     */

    void next(Coordinate coordinate);

    /**

     * Copies the state from the source {@link Coordinate} to the destination {@link Coordinate}.

     *

     * @param source      The source {@link Coordinate}.

     * @param destination The destination {@link Coordinate}.

     */

    void copy(Coordinate source, Coordinate destination);

    /**

     * Gets the {@link Color} associated with the state at the specified {@link Coordinate}.

     *

     * @param coordinate The {@link Coordinate} to retrieve the color for.

     * @return The {@link Color} associated with the state at the specified {@link Coordinate}.

     */

    Color getColor(Coordinate coordinate);

    /**

     * Sets a listener to be executed when the state at the specified {@link Coordinate} changes.

     *

     * @param coordinate The {@link Coordinate} to listen for changes.

     * @param listener   The listener to execute when the state changes.

     */

    void setChangeListener(Coordinate coordinate, Runnable listener);

    /**

     * Sets a listener to be executed when the generation number changes.

     *

     * @param listener The listener to execute when the generation number changes.

     */

    void setGenerationNumberChangeListener(OnChangeListener<Integer> listener);

    /**

     * Resets the simulation to random states.

     */

    void reset();

    /**

     * Clears the simulation, setting all states to their default values.

     */

    void clear();

}

package matrix;

public class ConstantMatrixInitializer<T> implements MatrixInitializer<T> {

  // TODO: add instance variables

  public ConstantMatrixInitializer(T constant) {

    // TODO

  }

    @Override

    public T initialValueAt(Coordinate coordinate) {

      // TODO

      return null;

    }

}

package matrix;

import java.util.List;

/**

 * Represents a 2D integer coordinate used to specify positions in a grid.

 */

public record Coordinate(int x, int y) {

    /**

     * Creates a new {@link Coordinate} instance with the given {@code x} and {@code y} values.

     *

     * @param x The x-coordinate value.

     * @param y The y-coordinate value.

     * @return A new {@link Coordinate} instance.

     */

    public static Coordinate of(int x, int y) {

        // TODO: compléter ce fabriquant

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} to the left of this one.

     *

     * @return The left adjacent {@link Coordinate}.

     */

    public Coordinate left() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} to the right of this one.

     *

     * @return The right adjacent {@link Coordinate}.

     */

    public Coordinate right() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} above this one.

     *

     * @return The above adjacent {@link Coordinate}.

     */

    public Coordinate above() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} below this one.

     *

     * @return The below adjacent {@link Coordinate}.

     */

    public Coordinate below() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns a list of orthogonal (adjacent in horizontal or vertical direction) neighbors.

     *  | | | |

     * ---------

     *  | |X| |

     * ---------

     *  |X|O|X|

     * ---------

     *  | |X| |

     * ---------

     * | | | |

     * @return A list of orthogonal neighboring {@link Coordinate}s.

     */

    public List<Coordinate> orthogonalNeighbours() {

        // TODO: à compléter

        return List.of();

    }

    /**

     * Computes and returns a list of diagonal (adjacent in diagonal direction) neighbors.

     *  | | | |

     * ---------

     *  |X| |X|

     * ---------

     *  | |O| |

     * ---------

     *  |X| |X|

     * ---------

     * | | | |

     *

     * @return A list of diagonal neighboring {@link Coordinate}s.

     */

    public List<Coordinate> diagonalNeighbours() {

        // TODO: à compléter

        return List.of();

    }

    /**

     * Computes and returns a list of all orthogonal and diagonal neighbors.

     *      *  | | | |

     *      * ---------

     *      *  |X|X|X|

     *      * ---------

     *      *  |X|O|X|

     *      * ---------

     *      *  |X|X|X|

     *      * ---------

     *      * | | | |

     *

     * @return A list of all neighboring {@link Coordinate}s.

     */

    public List<Coordinate> orthodiagonalNeighbours() {

        // TODO: à compléter

        return List.of();

    }

    @Override

    public String toString() {

        return "(" + this.x + "," + this.y + ")";

    }

  public Coordinate minus(Coordinate corner) {

    return new Coordinate(this.x - corner.x, this.y - corner.y);

  }

  public Coordinate plus(Coordinate corner) {

      return new Coordinate(this.x + corner.x, this.y + corner.y);

  }

}

 No newline at end of file

package matrix;

import java.util.Iterator;

import java.util.NoSuchElementException;

/**

 * An {@link Iterator} for generating 2D {@link Coordinate}s within a specified width and

 * height range.

 */

class CoordinateIterator implements Iterator<Coordinate> {

    /**

     * Creates a new {@link CoordinateIterator} with the specified width and height.

     *

     * @param width  The width of the coordinate range.

     * @param height The height of the coordinate range.

     */

    public CoordinateIterator(int width, int height) {

        // TODO: à compléter

    }

    /**

     * Checks if there are more {@link Coordinate}s to iterate over.

     *

     * @return true if there are more {@link Coordinate}s; otherwise, false.

     */

    @Override

    public boolean hasNext() {

        // TODO: à compléter

        return false;

    }

    /**

     * Returns the next {@link Coordinate} in the iteration.

     *

     * @return The next {@link Coordinate} in the iteration.

     * @throws NoSuchElementException if there are no more {@link Coordinate}s to iterate over.

     */

    @Override

    public Coordinate next() {

        // TODO: à compléter

        return null;

    }

}

package matrix;

import java.util.List;

/**

 * Represents a matrix, a rectangular array, with generic values in each cell.

 *

 * @param <T> The type of values stored in the matrix cells.

 */

public class ListMatrix<T> implements Matrix<T> {

  private final List<List<T>> matrix;

  private final int width;

  private final int height;

  /**

   * Creates a new {@link ListMatrix} with the specified width, height, and an initializer to set

   * values.

   *

   * @param width       The width of the {@link ListMatrix}.

   * @param height      The height of the {@link ListMatrix}.

   * @param initializer A matrix initializer to set values in the {@link ListMatrix}.

   */

  public ListMatrix(int width, int height, MatrixInitializer<T> initializer) {

    // TODO

    this.width = 0;

    this.height = 0;

    this.matrix = null;

    this.initializeWith(initializer); // fills the matrix using initializer

  }

  public ListMatrix(int width, int height, T constant) {

    this(width, height, new ConstantMatrixInitializer<>(constant));

  }

  private void initializeWith(MatrixInitializer<T> initializer) {

    // TODO initialize each cell of the matrix, with a value determined by initializer

  }

  public int width() {

    // TODO

    return 0;

  }

  public int height() {

    // TODO

    return 0;

  }

  @Override

  public T get(int x, int y) {

    // TODO

    return null;

  }

  @Override

  public void set(int x, int y, T newValue) {

    // TODO

  }

}

package matrix;

import java.util.Iterator;

public interface Matrix<T> extends Iterable<T> {

  /**

   * Returns the width of the {@link Matrix}.

   *

   * @return The width of the {@link Matrix}.

   */

  int width();

  /**

   * Returns the height of the {@link Matrix}.

   *

   * @return The height of the {@link Matrix}.

   */

  int height();

  /**

   * Returns the value at the specified coordinates (x, y) in

   * the {@link Matrix}.

   *

   * @param x The x-coordinate.

   * @param y The y-coordinate.

   * @return The content of the matrix at the coordinates (x,y).

   */

  T get(int x, int y);

  /**

   * Returns the value at the specified coordinates (x, y) in

   * the {@link Matrix}.

   *

   * @param coordinate The coordinates (x,y).

   * @return The content of the matrix at the coordinates (x,y).

   */

  default T get(Coordinate coordinate) {

    return this.get(coordinate.x(), coordinate.y());

  }

  /**

   *  Changes the value at the specified coordinates (x,y) in the {@link Matrix}

   *

   * @param x the x-coordinate

   * @param y the y-coordinate

   * @param newValue the value to assign to coordinates (x,y).

   */

  void set(int x, int y, T newValue);

  /**

   *  Changes the value at the specified coordinates (x,y) in the {@link Matrix}

   *

   * @param coordinate The coordinates (x,y)

   * @param newValue the value to assign to coordinates (x,y).

   */

  default void set(Coordinate coordinate, T newValue) {

    this.set(coordinate.x(), coordinate.y(), newValue);

  }

  default Matrix<T> subMatrix(Coordinate corner, int width, int height){

    return null ;

  }

  /**

   * Returns an {@link Iterable} that provides access to the {@link Coordinate}s of the

   * {@link Matrix} in row-major order. This means that a {@code for} loop on a {@link Matrix}

   * will loop over the coordinates of the {@link Matrix}.

   *

   * @return An {@link Iterable} for the {@link Coordinate}s of the {@link Matrix}.

   */

  default Iterable<Coordinate> coordinates() {

    return () -> new CoordinateIterator(this.width(), this.height());

  }

  /**

   * Returns an {@link Iterator} that allows iterating over the elements in the {@link Matrix} in

   * row-major order.

   *

   * @return An {@link Iterator} for the {@link Matrix}.

   */

  default Iterator<T> iterator() {

    Iterator<Coordinate> coords =

      new CoordinateIterator(this.width(),this.height());

    return new MatrixIterator<>(this, coords);

  }

}

package matrix;

/**

 * An interface for initializing a {@link ListMatrix} by providing initial values for each cell.

 *

 * @param <T> The type of values to initialize the {@link ListMatrix} with.

 */

public interface MatrixInitializer<T> {

    /**

     * Returns the initial value to be set in a {@link ListMatrix} cell at the specified

     * {@link Coordinate}.

     *

     * @param coordinate The {@link Coordinate} at which to set the initial value.

     * @return The initial value for the specified cell.

     */

    T initialValueAt(Coordinate coordinate);

}