build.gradle

@@ -4,7 +4,7 @@ plugins {
 }
 
 javafx {
-    version = "20"
+    version = "22"
     modules = [ 'javafx.controls', 'javafx.fxml' ]
 }
 
@@ -23,5 +23,5 @@ test {
 }
 
 application {
-    mainClassName = "GameOfLifeApplication"
+    mainClassName = "SimulatorApplication"
 }
\ No newline at end of file

gradle/wrapper/gradle-wrapper.properties

 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

src/main/java/GameOfLifeApplication.java → src/main/java/SimulatorApplication.java

 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.CellGrid;
-import model.CellularAutomataSimulation;
-import model.GameOfLifeState;
+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 CellularAutomataSimulation<GameOfLifeState> gameOfLife;
+  private final Simulation simulation;
   private Stage primaryStage;
   private Parent view;
 
   /**
    * Creates a new {@code GameOfLifeApplication} instance.
    */
-  public GameOfLifeApplication() {
-    this(new CellularAutomataSimulation<GameOfLifeState>(
-            new CellGrid<>(NUMBER_OF_COLUMNS, NUMBER_OF_ROWS, GameOfLifeState.ALIVE),
-            GameOfLifeState.DEAD,
-            GameOfLifeState::random
-    ));
+  public SimulatorApplication() {
+    this.simulation =
+      new CellularAutomatonSimulation<>(
+              new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),
+              GENERATOR
+      );
   }
 
-  /**
-   * Creates a new {@code GameOfLifeApplication} instance given a {@link CellularAutomataSimulation} instance.
-   *
-   * @param cellularAutomataSimulation the {@link CellularAutomataSimulation} instance
-   * @throws NullPointerException if {@code gameOfLife} is {@code null}
-   */
-  private GameOfLifeApplication(CellularAutomataSimulation<GameOfLifeState> cellularAutomataSimulation) {
-    this.gameOfLife = requireNonNull(cellularAutomataSimulation, "game of life is null");
-  }
 
   @Override
   public void start(Stage primaryStage) throws IOException {
@@ -68,11 +60,11 @@ public class GameOfLifeApplication extends Application {
 
   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.setSimulation(gameOfLife);
+    controller.setSimulation(simulation);
   }
 
 

src/main/java/controller/Controller.java

 package controller;
 
-import datastruct.Coordinate;
+import matrix.Coordinate;
 import javafx.animation.Animation;
 import javafx.animation.KeyFrame;
 import javafx.animation.Timeline;
@@ -11,7 +11,6 @@ import javafx.scene.control.Label;
 import javafx.scene.control.ToggleButton;
 import javafx.scene.control.ToggleGroup;
 import javafx.util.Duration;
-import model.CellularAutomataSimulation;
 import view.MatrixPane;
 
 import static java.util.Objects.requireNonNull;
@@ -51,13 +50,6 @@ public class Controller {
     }
 
 
-    /**
-     * Sets {@link CellularAutomataSimulation} instance.
-     *
-     * @param simulation {@link CellularAutomataSimulation} instance
-     * @throws NullPointerException if {@code gameOfLife} is {@code null}
-     */
-
     public void setSimulation(Simulation simulation) {
         this.simulation = requireNonNull(simulation, "game of life is null");
         setGenerationNumberLabelTextProperty();
@@ -65,7 +57,14 @@ public class Controller {
     }
 
     private void setGenerationNumberLabelTextProperty() {
-        generationNumberLabel.textProperty().bind(simulation.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() {

src/main/java/controller/Simulation.java

 package controller;
 
-import datastruct.Coordinate;
-import javafx.beans.property.ReadOnlyLongProperty;
+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);
 
-    void setChangeListener(Coordinate coordinate, Runnable run);
+    /**
+     * 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);
 
-    ReadOnlyLongProperty generationNumberProperty();
+    /**
+     * 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();
 }

src/main/java/datastruct/Coordinate.java

-package datastruct;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public record Coordinate(int x, int y) {
-
-    public static Coordinate of(int x, int y) {
-        return new Coordinate(x,y);
-    }
-
-    public Coordinate left() {
-        return new Coordinate(x-1,y);
-    }
-
-    public Coordinate right() {
-        return new Coordinate(x+1,y);
-    }
-
-    public Coordinate above() {
-        return new Coordinate(x,y+1);
-    }
-
-    public Coordinate below() {
-        return new Coordinate(x, y-1);
-    }
-
-    public List<Coordinate> orthogonalNeighbours() {
-        return List.of(
-                this.right(),
-                this.left(),
-                this.above(),
-                this.below()
-        );
-    }
-
-    public List<Coordinate> diagonalNeighbours() {
-        return List.of(
-                this.right().above(),
-                this.left().above(),
-                this.left().below(),
-                this.right().below()
-        );
-    }
-
-    public List<Coordinate> orthodiagonalNeighbours() {
-        List<Coordinate> neighbours = new ArrayList<>(this.orthogonalNeighbours());
-        neighbours.addAll(this.diagonalNeighbours());
-        return neighbours;
-    }
-}

src/main/java/datastruct/CoordinateIterator.java

-package datastruct;
-
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-class CoordinateIterator implements Iterator<Coordinate> {
-    private final int width;
-    private final int height;
-    private int x = 0;
-    private int y = 0;
-
-    public CoordinateIterator(int width, int height) {
-        this.width = width;
-        this.height = height;
-    }
-
-    @Override
-    public boolean hasNext() {
-        return y < this.height;
-    }
-
-    @Override
-    public Coordinate next() {
-        if (!this.hasNext()) {
-            throw new NoSuchElementException();
-        }
-        Coordinate coord = new Coordinate(this.x, this.y);
-        this.x = this.x + 1;
-        if (this.x == this.width) {
-            this.x = 0;
-            this.y = this.y + 1;
-        }
-        return coord;
-    }
-}

src/main/java/datastruct/Lens.java

-package datastruct;
-
-public interface Lens<S> {
-    S get();
-
-    void set(S value);
-}

src/main/java/datastruct/Matrix.java

-package datastruct;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-public class Matrix<T> {
-
-    private final List<List<T>> matrix;
-    private final int width;
-    private final int height;
-
-    public Matrix(int width, int height, MatrixInitializer<T> initializer) {
-        this.width = width;
-        this.height = height;
-        this.matrix = new ArrayList<>();
-        this.initializeWith(initializer);
-    }
-
-    public Matrix(int width, int height, T initialValue) {
-        this(width, height, new ConstantMatrixInitializer<>(initialValue));
-    }
-
-    private void initializeWith(MatrixInitializer<T> initializer) {
-        for (int x = 0; x < width; x++) {
-            List<T> row = new ArrayList<>();
-            this.matrix.add(row);
-            for (int y = 0; y < height; y++) {
-                row.add(initializer.initialValueAt(Coordinate.of(x,y)));
-            }
-        }
-    }
-
-    public T get(int x, int y) {
-        return this.matrix.get(x).get(y);
-    }
-
-    public T get(Coordinate coord) {
-        return this.get(coord.x(), coord.y());
-    }
-
-    public void set(int x, int y, T value) {
-        this.matrix.get(x).set(y,value);
-    }
-
-    public void set(Coordinate coord, T value) {
-        this.set(coord.x(), coord.y(), value);
-    }
-
-
-    public Iterator<T> iterator() {
-        Iterator<Coordinate> coordIterator = this.coordinatesIterator();
-        return new MatrixIterator(this, coordIterator);
-    }
-
-    public Iterable<Coordinate> coordinates() {
-        return this::coordinatesIterator;
-    }
-
-    private Iterator<Coordinate> coordinatesIterator() {
-        return new CoordinateIterator(this.width, this.height);
-    }
-
-
-    public Lens<T> at(int x, int y) {
-        return new Lens<T>() {
-            @Override
-            public T get() {
-                return Matrix.this.get(x,y);
-            }
-
-            @Override
-            public void set(T value) {
-                Matrix.this.set(x,y,value);
-            }
-        };
-    }
-
-    public Lens<T> at(Coordinate coord) {
-        return this.at(coord.x(), coord.y());
-    }
-
-}

src/main/java/datastruct/MatrixInitializer.java

-package datastruct;
-
-public interface MatrixInitializer<T> {
-
-    T initialValueAt(Coordinate coordinate);
-}

src/main/java/datastruct/ConstantMatrixInitializer.java → src/main/java/matrix/ConstantMatrixInitializer.java

-package datastruct;
+package matrix;
 
 public class ConstantMatrixInitializer<T> implements MatrixInitializer<T> {
 
-    private final T constant;
+  // TODO: add instance variables
+
+  public ConstantMatrixInitializer(T constant) {
+    // TODO
+  }
 
-    public ConstantMatrixInitializer(T constant) {
-        this.constant = constant;
-    }
     @Override
     public T initialValueAt(Coordinate coordinate) {
-        return constant;
+      // TODO
+      return null;
     }
 }

src/main/java/matrix/Coordinate.java

+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

src/main/java/matrix/CoordinateIterator.java

+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;
+    }
+}

src/main/java/matrix/ListMatrix.java

+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
+  }
+
+  public Matrix<T> subMatrix(Coordinate corner, int width, int height) {
+    // TODO
+    return this;
+  }
+
+}

src/main/java/matrix/Matrix.java

+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);
+  }
+
+  Matrix<T> subMatrix(Coordinate corner, int width, int height);
+
+
+  /**
+   * 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);
+  }
+}

src/main/java/matrix/MatrixInitializer.java

+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);
+}

src/main/java/datastruct/MatrixIterator.java → src/main/java/matrix/MatrixIterator.java

-package datastruct;
+package matrix;
 
 import java.util.Iterator;
 import java.util.NoSuchElementException;

src/main/java/model/Cell.java

 package model;
 
-import javafx.beans.property.Property;
-import javafx.beans.property.SimpleObjectProperty;
-import javafx.scene.paint.Color;
+import java.util.ArrayList;
+import java.util.List;
+
 
 /**
- * {@link Cell} instances represent the cells of <i>The Game of Life</i>.
+ * A class representing a cell that holds a value and allows adding listeners to track value changes.
+ *
+ * @param <T> The type of value stored in the cell.
  */
+public class Cell<T> implements Lens<T> {
 
-public class Cell<S extends State<S>> {
-    private final Property<S> stateProperty;
+    //TODO: ajouter la ou les propriétés nécessaires
 
-    public Cell(S initialState) {
-        this.stateProperty = new SimpleObjectProperty<>(initialState);
-    }
+    // la liste des objets écoutant les modifications du contenu de la cellule
+    private final List<OnChangeListener<T>> listeners = new ArrayList<>();
 
-    /**
-     * Determines the color associated with the state in which
-     * this {@link Cell} is.
+    /** Initialize a new cell with a given value.
      *
-     * @return the {@link Color} associated with the state in
-     * which this {@link Cell} is
+     * @param initialContent the value initially stored by the cell.
      */
-
-    public Color getColor() {
-        return this.getState().getColor();
+    public Cell(T initialContent) {
+        //TODO: à compléter
     }
 
-    /**
-     * Sets the state of this {@link Cell}.
+    /** Add a {@link OnChangeListener} to react to any change of value in the cell.
      *
-     * @param state the new state of this {@link Cell}
+     * @param listener the {@link OnChangeListener} to activate when the value in the cell is
+     *                 changed.
      */
-
-    public void setState(S state) {
-        getStateProperty().setValue(state);
+    public void addOnChangeListener(OnChangeListener<T> listener) {
+        this.listeners.add(listener);
     }
 
     /**
-     * Returns the current state of this {@link Cell}.
+     * Sets the content of this {@link Cell}. This will also call all the listeners that were
+     * registered by the method {@code addOnChangeListener}.
      *
-     * @return the current state of this {@link Cell}
+     * @param value the new content of this {@link Cell}
      */
-
-    public S getState(){
-        return getStateProperty().getValue();
+    public void set(T value) {
+        //TODO: modifier le contenu de la cellule, puis appeler les méthodes valueChanged des
+        // listeners
     }
 
     /**
-     * Change the state of this {@link Cell} to the next possible state.
-     */
-
-    public void toggleState() {
-        setState(getState().next());
-    }
-
-    /**
-     * Returns this {@link Cell}'s state property.
+     * Returns the current content of this {@link Cell}.
      *
-     * @return this {@link Cell}'s state property.
+     * @return the current content of this {@link Cell}
      */
-    public Property<S> getStateProperty() {
-        return stateProperty;
+    public T get(){
+        //TODO: à compléter
+        return null;
     }
-
 }

src/main/java/model/CellGrid.java

-package model;
-
-import datastruct.Coordinate;
-import datastruct.Lens;
-import datastruct.Matrix;
-
-import java.util.Iterator;
-import java.util.function.Supplier;
-
-
-/**
- * {@link CellGrid} instances represent the grid in <i>The Game of Life</i>.
- */
-public class CellGrid<S extends State<S>> implements Iterable<Cell<S>> {
-
-    private final int numberOfRows;
-    private final int numberOfColumns;
-    private final Matrix<Cell<S>> cells;
-
-    /**
-     * Creates a new {@code Grid} instance given the number of rows and columns.
-     *
-     * @param numberOfColumns the number of columns
-     * @param numberOfRows    the number of rows
-     * @throws IllegalArgumentException if {@code numberOfRows} or {@code numberOfColumns} are
-     *                                  less than or equal to 0
-     */
-    public CellGrid(int numberOfColumns, int numberOfRows, S defaultState) {
-        this.numberOfRows = numberOfRows;
-        this.numberOfColumns = numberOfColumns;
-        this.cells = new Matrix<>(numberOfColumns, numberOfRows, coord -> new Cell<>(defaultState));
-    }
-
-
-    public boolean contains(Coordinate coordinate) {
-        return (coordinate.x() >= 0)
-                && (coordinate.x() < this.numberOfColumns)
-                && (coordinate.y() > 0)
-                && (coordinate.y() <= this.numberOfRows);
-    }
-
-
-    /**
-     * Returns an iterator over the cells in this {@code Grid}.
-     *
-     * @return an iterator over the cells in this {@code Grid}
-     */
-    @Override
-    public Iterator<Cell<S>> iterator() {
-        return this.cells.iterator();
-    }
-
-    public Iterable<Coordinate> coordinates() {
-        return this.cells.coordinates();
-    }
-
-    public Lens<S> at(Coordinate coord) {
-        return new CellLens<>(this.cellAt(coord));
-    }
-
-
-    public Cell<S> cellAt(Coordinate coord) {
-        return this.cells.at(coord).get();
-    }
-
-    private Coordinate wrap(Coordinate coordinate) {
-        return new Coordinate(
-                 modulo(coordinate.x(), getNumberOfColumns()),
-                 modulo(coordinate.y(), getNumberOfRows())
-                );
-    }
-
-    private static int modulo(int n, int d) {
-        int result = n % d;
-        return n < 0 ? result + d : result;
-    }
-    public Lens<S> atWrapped(Coordinate coord) {
-        return this.at(wrap(coord));
-    }
-
-    public Cell<S> cellAtWrapped(Coordinate coord) {
-        return this.cellAt(wrap(coord));
-    }
-
-    /**
-     * Returns the number of rows in this {@code Grid}.
-     *
-     * @return the number of rows in this {@code Grid}
-     */
-    public int getNumberOfRows() {
-        return numberOfRows;
-    }
-
-    /**
-     * Returns the number of columns in this {@code Grid}.
-     *
-     * @return the number of columns in this {@code Grid}
-     */
-    public int getNumberOfColumns() {
-        return numberOfColumns;
-    }
-
-
-
-
-    private Matrix<S> nextGenerationMatrix() {
-        return new Matrix<>(
-                this.numberOfColumns,
-                this.numberOfRows,
-                new OneStepMatrixInitializer<>(this)
-        );
-    }
-
-    /**
-     * Transitions all {@link Cell}s in this {@code Grid} to the next generation.
-     *
-     * <p>The following rules are applied:
-     * <ul>
-     * <li>Any live {@link Cell} with fewer than two live neighbours dies, i.e. underpopulation.</li>
-     * <li>Any live {@link Cell} with two or three live neighbours lives on to the next
-     * generation.</li>
-     * <li>Any live {@link Cell} with more than three live neighbours dies, i.e. overpopulation.</li>
-     * <li>Any dead {@link Cell} with exactly three live neighbours becomes a live cell, i.e.
-     * reproduction.</li>
-     * </ul>
-     */
-    // TODO: Écrire une version correcte de cette méthode.
-    public void updateToNextGeneration() {
-        Matrix<S> nextStates = this.nextGenerationMatrix();
-        for (Coordinate coordinate : this.coordinates()) {
-            this.cellAt(coordinate).setState(nextStates.get(coordinate));
-        }
-    }
-
-
-    /**
-     * Sets all {@link Cell}s in this {@code Grid} as dead.
-     */
-    // TODO: Écrire une version correcte de cette méthode.
-    public void clear(S clearState) {
-        for (Cell<S> cell : this) {
-            cell.setState(clearState);
-        }
-    }
-
-
-    /**
-     * Goes through each {@link Cell} in this {@code Grid} and sets it states with a
-     * state obtained from the supplier.
-     *
-     * @param supplier {@link Supplier} instance used to decide a state for each cell {@link Cell}.
-     * @throws NullPointerException if {@code supplier} is {@code null}.
-     */
-    // TODO: Écrire une version correcte de cette méthode.
-    public void fillRandomly(Supplier<S> supplier) {
-        for (Cell<S> cell : this) {
-            cell.setState(supplier.get());
-        }
-    }
-}

src/main/java/model/CellLens.java

-package model;
-
-import datastruct.Lens;
-
-public class CellLens<S extends State<S>> implements Lens<S> {
-
-    private final Cell<S> cell;
-
-    public CellLens(Cell<S> cell) {
-        this.cell = cell;
-    }
-
-    @Override
-    public S get() {
-        return cell.getState();
-    }
-
-    @Override
-    public void set(S value) {
-        cell.setState(value);
-    }
-}