.gitlab-ci.yml

-image: gradle:jdk17
+image: openjdk:17-alpine
 
 variables:
   GRADLE_OPTS: "-Dorg.gradle.daemon=false"
@@ -25,9 +25,9 @@ build:
       - build
       - .gradle
 
-test:
+java:
   stage: test
-  script: ./gradlew check
+  script: ./gradlew test
   artifacts:
     when: always
     reports:

README.md

@@ -2,16 +2,20 @@
 
 ## 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
 

build.gradle

 plugins {
     id 'application'
-    id "org.openjfx.javafxplugin" version "0.0.10"
+    id "org.openjfx.javafxplugin" version "0.0.14"
 }
 
 javafx {
-    version = "17"
+    version = "22"
     modules = [ 'javafx.controls', 'javafx.fxml' ]
 }
 
@@ -13,9 +13,9 @@ repositories {
 }
 
 dependencies {
-    testImplementation('org.junit.jupiter:junit-jupiter-api:5.8.0',
-            'org.assertj:assertj-core:3.20.2')
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0'
+    testImplementation('org.junit.jupiter:junit-jupiter-api:5.10.0',
+            'org.assertj:assertj-core:3.24.2')
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
 }
 
 test {
@@ -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-7.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

 #!/usr/bin/env sh
 
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
 ##############################################################################
 ##
 ##  Gradle start up script for UN*X
@@ -44,7 +28,7 @@ APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+DEFAULT_JVM_OPTS=""
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
@@ -72,7 +56,7 @@ case "`uname`" in
   Darwin* )
     darwin=true
     ;;
-  MSYS* | MINGW* )
+  MINGW* )
     msys=true
     ;;
   NONSTOP* )
@@ -82,7 +66,6 @@ esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
-
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
@@ -126,11 +109,10 @@ if $darwin; then
     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
 fi
 
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
     JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
@@ -156,19 +138,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
         else
             eval `echo args$i`="\"$arg\""
         fi
-        i=`expr $i + 1`
+        i=$((i+1))
     done
     case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
@@ -177,9 +159,14 @@ save () {
     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
     echo " "
 }
-APP_ARGS=`save "$@"`
+APP_ARGS=$(save "$@")
 
 # Collect all arguments for the java command, following the shell quoting and substitution rules
 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
 
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
 exec "$JAVACMD" "$@"

gradlew.bat

-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='-Dfile.encoding=UTF-8 "-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

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.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 {
@@ -63,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.setGameOfLife(gameOfLife);
+    controller.setSimulation(simulation);
   }
 
 

src/main/java/controller/Controller.java

 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;
@@ -15,6 +20,7 @@ import static java.util.Objects.requireNonNull;
  */
 public class Controller {
 
+    public static final int PERIOD_IN_MILLISECONDS = 100;
     @FXML
     private ToggleButton playToggleButton;
     @FXML
@@ -23,12 +29,18 @@ public class Controller {
     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() {
@@ -38,47 +50,77 @@ public class Controller {
     }
 
 
-    /**
-     * 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();
+    }
 }

src/main/java/controller/Simulation.java

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

src/main/java/matrix/ConstantMatrixInitializer.java

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

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/matrix/MatrixIterator.java

+package matrix;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+class MatrixIterator<T> implements Iterator<T> {
+    private final Iterator<Coordinate> coordIterator;
+    private final Matrix<T> matrix;
+
+    public MatrixIterator(Matrix<T> matrix, Iterator<Coordinate> coordIterator) {
+        this.coordIterator = coordIterator;
+        this.matrix = matrix;
+    }
+
+    @Override
+    public boolean hasNext() {
+        return coordIterator.hasNext();
+    }
+
+    @Override
+    public T next() {
+        if (!hasNext()) {
+            throw new NoSuchElementException();
+        }
+        return matrix.get(coordIterator.next());
+    }
+}

src/main/java/model/Cell.java

 package model;
 
-import javafx.beans.property.Property;
-import javafx.beans.property.SimpleObjectProperty;
+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 {
-    private final Property<CellState> stateProperty = new SimpleObjectProperty<>(CellState.DEAD);
+    //TODO: ajouter la ou les propriétés nécessaires
 
-    /**
-     * Determines whether this {@link Cell} is alive or not.
-     *
-     * @return {@code true} if this {@link Cell} is alive and {@code false} otherwise
-     */
+    // la liste des objets écoutant les modifications du contenu de la cellule
+    private final List<OnChangeListener<T>> listeners = new ArrayList<>();
 
-    public boolean isAlive() {
-        return getState().isAlive;
-    }
-
-    /**
-     * Sets the state of this {@link Cell}.
+    /** Initialize a new cell with a given value.
      *
-     * @param cellState the new state of this {@link Cell}
+     * @param initialContent the value initially stored by the cell.
      */
-
-    public void setState(CellState cellState) {
-        getStateProperty().setValue(cellState);
+    public Cell(T initialContent) {
+        //TODO: à compléter
     }
 
-    /**
-     * Returns the current state of this {@link Cell}.
+    /** Add a {@link OnChangeListener} to react to any change of value in the cell.
      *
-     * @return the current state of this {@link Cell}
+     * @param listener the {@link OnChangeListener} to activate when the value in the cell is
+     *                 changed.
      */
-
-    public CellState getState(){
-        return getStateProperty().getValue();
+    public void addOnChangeListener(OnChangeListener<T> listener) {
+        this.listeners.add(listener);
     }
 
     /**
-     * Change the state of this {@link Cell} from ALIVE to DEAD or from DEAD to ALIVE.
+     * Sets the content of this {@link Cell}. This will also call all the listeners that were
+     * registered by the method {@code addOnChangeListener}.
+     *
+     * @param value the new content of this {@link Cell}
      */
-
-    public void toggleState() {
-        CellState[] possibleStates = CellState.values();
-        int stateOrdinal = getState().ordinal();
-        int numberOfPossibleStates = possibleStates.length;
-        setState(possibleStates[(stateOrdinal+1)%numberOfPossibleStates]);
+    public void set(T value) {
+        //TODO: modifier le contenu de la cellule, puis appeler les méthodes valueChanged des
+        // listeners
     }
 
     /**
-     * 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<CellState> getStateProperty() {
-        return stateProperty;
+    public T get(){
+        //TODO: à compléter
+        return null;
     }
-
 }

src/main/java/model/CellState.java

-package model;
-
-import javafx.scene.paint.Color;
-
-/**
- * {@link CellState} instances represent the possible states of a {@link CellState}.
- */
-public enum CellState {
-    ALIVE(true, Color.RED),
-    DEAD(false, Color.WHITE);
-
-    public final boolean isAlive;
-    public final Color color;
-
-    CellState(boolean isAlive, Color color) {
-        this.isAlive = isAlive;
-        this.color = color;
-    }
-}

src/main/java/model/CellularAutomaton.java

+package model;
+
+import java.util.Random;
+
+/**
+ * Represents a cellular automaton, which defines the main parameters of a cellular automaton.
+ * The rules for updating states are defined in the class used as {@code S}.
+ *
+ * @param <S> The type of state used in the cellular automaton.
+ */
+public interface CellularAutomaton<S extends State<S>> {
+
+    /**
+     * Returns the number of columns in the grid of the cellular automaton.
+     *
+     * @return The number of columns in the grid.
+     */
+    int numberOfColumns();
+
+    /**
+     * Returns the number of rows in the grid of the cellular automaton.
+     *
+     * @return The number of rows in the grid.
+     */
+    int numberOfRows();
+
+    /**
+     * Returns the default state that is used to initialize cells in the automaton.
+     *
+     * @return The default state for cells in the automaton.
+     */
+    S defaultState();
+
+
+    /**
+     * Generates a random state using the specified random number generator.
+     *
+     * @param generator The random number generator to use.
+     * @return A randomly generated state.
+     */
+    S randomState(Random generator);
+}
\ No newline at end of file

src/main/java/model/CellularAutomatonSimulation.java

+package model;
+
+import controller.Simulation;
+import matrix.Coordinate;
+import matrix.ListMatrix;
+import javafx.scene.paint.Color;
+
+import java.util.Iterator;
+import java.util.Random;
+
+
+
+/**
+ * {@link CellularAutomatonSimulation} instances run <i>The Game of Life</i>.
+ *
+ *  @param <S> The type of state used in the simulation.
+ */
+public class CellularAutomatonSimulation<S extends State<S>>
+        implements Simulation {
+
+    private final ListMatrix<Cell<S>> grid;
+    private final Cell<Integer> generationNumber = new Cell<>(0);
+    private final CellularAutomaton<S> automaton;
+    private final Random generator;
+
+    /**
+     * Creates a new {@link CellularAutomatonSimulation} instance for a given automaton.
+     *
+     * @param automaton  A description of the {@link CellularAutomaton}.
+     * @param generator  The {@link Random} instance used for random state generation.
+     */
+    public CellularAutomatonSimulation(CellularAutomaton<S> automaton, Random generator) {
+        this.automaton = automaton;
+        this.grid = new ListMatrix<>(
+                automaton.numberOfColumns(),
+                automaton.numberOfRows(),
+                new ConstantCellInitializer<>(automaton.defaultState())
+        );
+        this.generator = generator;
+    }
+
+
+    @Override
+    public int numberOfColumns() {
+        //TODO: à compléter
+        return 0;
+    }
+
+    @Override
+    public int numberOfRows() {
+        //TODO: à compléter
+        return 0;
+    }
+
+    /**
+     * Returns the {@link Cell} at the specified coordinate.
+     *
+     * @param coordinate The coordinate of the cell to retrieve.
+     * @return The cell at the specified coordinate.
+     */
+    public Cell<S> at(Coordinate coordinate) {
+        //TODO: à compléter
+        return null;
+    }
+
+    @Override
+    public void updateToNextGeneration() {
+        //TODO: à compléter, en utilisant nextGenerationMatrix()
+    }
+
+    /** Computes the {@link ListMatrix} of states obtained after a single step of updates
+     * of the simulation.
+     *
+     * @return the states of each cell after one generation
+     */
+    private ListMatrix<S> nextGenerationMatrix() {
+        //TODO: à compléter
+        return null;
+    }
+    @Override
+    public void next(Coordinate coordinate) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public void copy(Coordinate source, Coordinate destination) {
+        //TODO: à compléter
+    }
+
+    @Override
+    public Color getColor(Coordinate coordinate) {
+        //TODO: à compléter
+        return null;
+    }
+
+    @Override
+    public void setChangeListener(Coordinate coordinate, Runnable listener) {
+        this.at(coordinate).addOnChangeListener(
+                (oldValue, newValue) -> listener.run()
+        );
+    }
+
+    @Override
+    public void setGenerationNumberChangeListener(OnChangeListener<Integer> listener){
+        this.generationNumber.addOnChangeListener(listener);
+    }
+
+
+    @Override
+    public void clear() {
+        //TODO: à compléter (penser à remettre le nombre de génération à 0)
+    }
+
+
+    @Override
+    public void reset() {
+        //TODO: à compléter (penser à remettre le nombre de génération à 0)
+    }
+
+    @Override
+    public Iterator<Coordinate> iterator() {
+        return this.grid.coordinates().iterator();
+    }
+}