15ab66ec7950bf24b213e1726ca169f9546af98f to main · YAGOUBI Rim / Game of life Template

.gitlab-ci.yml

+26
−4

Original line number
Original line
Diff line number
Diff line

image: gradle:jdk16

image: openjdk:17-alpine

variables:

  GRADLE_OPTS: "-Dorg.gradle.daemon=false"

before_script:

before_script:

  - export GRADLE_USER_HOME=`pwd`/.gradle

  - export GRADLE_USER_HOME=`pwd`/.gradle

@@ -8,11 +11,30 @@ cache:

    - .gradle/wrapper

    - .gradle/wrapper

    - .gradle/caches

    - .gradle/caches

stages:

  - build

  - test

build:

  stage: build

  script: ./gradlew --build-cache assemble

  cache:

    key: "$CI_COMMIT_REF_NAME"

    policy: push

    paths:

      - build

      - .gradle

java:

java:

  stage: test

  stage: test

  script:

  script: ./gradlew test

    - gradle test

  artifacts:

  artifacts:

    when: always

    when: always

    reports:

    reports:

      junit: build/test-results/test/**/TEST-*.xml

      junit: build/test-results/test/**/TEST-*.xml

  cache:

    key: "$CI_COMMIT_REF_NAME"

    policy: pull

    paths:

      - build

      - .gradle

 No newline at end of file

README.md

+14
−9

Original line number
Original line
Diff line number
Diff line

@@ -2,17 +2,22 @@

## Description du projet 

## 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 morte possédant exactement trois voisines vivantes devient vivante.

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

- 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 

## Membres du projet

jeu de la vie.

## Membre du projet

- NOM, prénom, du participant

- NOM, prénom, numéro de groupe, du premier participant

- NOM, prénom, numéro de groupe, du deuxième participant

build.gradle

+6
−6

Original line number
Original line
Diff line number
Diff line

plugins {

plugins {

    id 'application'

    id 'application'

    id "org.openjfx.javafxplugin" version "0.0.10"

    id "org.openjfx.javafxplugin" version "0.0.14"

}

}

javafx {

javafx {

    version = "17"

    version = "22"

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

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

}

}

@@ -13,9 +13,9 @@ repositories {

}

}

dependencies {

dependencies {

    testImplementation('org.junit.jupiter:junit-jupiter-api:5.8.0',

    testImplementation('org.junit.jupiter:junit-jupiter-api:5.10.0',

            'org.assertj:assertj-core:3.20.2')

            'org.assertj:assertj-core:3.24.2')

    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.0'

    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'

}

}

test {

test {

@@ -23,5 +23,5 @@ test {

}

}

application {

application {

    mainClassName = "GameOfLifeApplication"

    mainClassName = "SimulatorApplication"

}

}

 No newline at end of file

gradle/wrapper/gradle-wrapper.properties

+1
−1

Original line number
Original line
Diff line number
Diff line

distributionBase=GRADLE_USER_HOME

distributionBase=GRADLE_USER_HOME

distributionPath=wrapper/dists

distributionPath=wrapper/dists

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

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

zipStoreBase=GRADLE_USER_HOME

zipStoreBase=GRADLE_USER_HOME

zipStorePath=wrapper/dists

zipStorePath=wrapper/dists

gradlew

+21
−34

Original line number
Original line
Diff line number
Diff line

#!/usr/bin/env sh

#!/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

##  Gradle start up script for UN*X

@@ -44,7 +28,7 @@ APP_NAME="Gradle"

APP_BASE_NAME=`basename "$0"`

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.

# 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.

# Use the maximum available, or set MAX_FD != -1 to use that value.

MAX_FD="maximum"

MAX_FD="maximum"

@@ -72,7 +56,7 @@ case "`uname`" in

  Darwin* )

  Darwin* )

    darwin=true

    darwin=true

    ;;

    ;;

  MSYS* | MINGW* )

  MINGW* )

    msys=true

    msys=true

    ;;

    ;;

  NONSTOP* )

  NONSTOP* )

@@ -82,7 +66,6 @@ esac

CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

# Determine the Java command to use to start the JVM.

# Determine the Java command to use to start the JVM.

if [ -n "$JAVA_HOME" ] ; then

if [ -n "$JAVA_HOME" ] ; then

    if [ -x "$JAVA_HOME/jre/sh/java" ] ; 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\""

    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""

fi

fi

# For Cygwin or MSYS, switch paths to Windows format before running java

# For Cygwin, switch paths to Windows format before running java

if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then

if $cygwin ; then

    APP_HOME=`cygpath --path --mixed "$APP_HOME"`

    APP_HOME=`cygpath --path --mixed "$APP_HOME"`

    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`

    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`

    JAVACMD=`cygpath --unix "$JAVACMD"`

    JAVACMD=`cygpath --unix "$JAVACMD"`

    # We build the pattern for arguments to be converted via cygpath

    # We build the pattern for arguments to be converted via cygpath

@@ -156,19 +138,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then

        else

        else

            eval `echo args$i`="\"$arg\""

            eval `echo args$i`="\"$arg\""

        fi

        fi

        i=`expr $i + 1`

        i=$((i+1))

    done

    done

    case $i in

    case $i in

        0) set -- ;;

        (0) set -- ;;

        1) set -- "$args0" ;;

        (1) set -- "$args0" ;;

        2) set -- "$args0" "$args1" ;;

        (2) set -- "$args0" "$args1" ;;

        3) set -- "$args0" "$args1" "$args2" ;;

        (3) set -- "$args0" "$args1" "$args2" ;;

        4) set -- "$args0" "$args1" "$args2" "$args3" ;;

        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;

        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;

        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;

        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;

        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;

        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;

        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;

        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;

        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;

        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;

        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;

    esac

    esac

fi

fi

@@ -177,9 +159,14 @@ save () {

    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done

    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done

    echo " "

    echo " "

}

}

APP_ARGS=`save "$@"`

APP_ARGS=$(save "$@")

# Collect all arguments for the java command, following the shell quoting and substitution rules

# 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"

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" "$@"

exec "$JAVACMD" "$@"

gradlew.bat

+244
−89

Original line number
Original line
Diff line number
Diff line

@rem

#!/bin/sh

@rem Copyright 2015 the original author or authors.

@rem

#

@rem Licensed under the Apache License, Version 2.0 (the "License");

# Copyright © 2015-2021 the original authors.

@rem you may not use this file except in compliance with the License.

#

@rem You may obtain a copy of the License at

# Licensed under the Apache License, Version 2.0 (the "License");

@rem

# you may not use this file except in compliance with the License.

@rem      https://www.apache.org/licenses/LICENSE-2.0

# You may obtain a copy of the License at

@rem

#

@rem Unless required by applicable law or agreed to in writing, software

#      https://www.apache.org/licenses/LICENSE-2.0

@rem distributed under the License is distributed on an "AS IS" BASIS,

#

@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# Unless required by applicable law or agreed to in writing, software

@rem See the License for the specific language governing permissions and

# distributed under the License is distributed on an "AS IS" BASIS,

@rem limitations under the License.

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

@rem

# See the License for the specific language governing permissions and

# limitations under the License.

@if "%DEBUG%" == "" @echo off

#

@rem ##########################################################################

@rem

##############################################################################

@rem  Gradle startup script for Windows

#

@rem

#   Gradle start up script for POSIX generated by Gradle.

@rem ##########################################################################

#

#   Important for running:

@rem Set local scope for the variables with windows NT shell

#

if "%OS%"=="Windows_NT" setlocal

#   (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

set DIRNAME=%~dp0

#       bash, then to run this script, type that shell name before the whole

if "%DIRNAME%" == "" set DIRNAME=.

#       command line, like:

set APP_BASE_NAME=%~n0

#

set APP_HOME=%DIRNAME%

#           ksh Gradle

#

@rem Resolve any "." and ".." in APP_HOME to make it shorter.

#       Busybox and similar reduced shells will NOT work, because this script

for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi

#       requires all of these POSIX shell features:

#         * functions;

@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,

set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;

#         * compound commands having a testable exit status, especially «case»;

@rem Find java.exe

#         * various built-in commands including «command», «set», and «ulimit».

if defined JAVA_HOME goto findJavaFromJavaHome

#

#   Important for patching:

set JAVA_EXE=java.exe

#

%JAVA_EXE% -version >NUL 2>&1

#   (2) This script targets any POSIX shell, so it avoids extensions provided

if "%ERRORLEVEL%" == "0" goto execute

#       by Bash, Ksh, etc; in particular arrays are avoided.

#

echo.

#       The "traditional" practice of packing multiple parameters into a

echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

#       space-separated string is a well documented source of bugs and security

echo.

#       problems, so this is (mostly) avoided, by progressively accumulating

echo Please set the JAVA_HOME variable in your environment to match the

#       options in "$@", and eventually passing that to Java.

echo location of your Java installation.

#

#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,

goto fail

#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;

#       see the in-line comments for details.

:findJavaFromJavaHome

#

set JAVA_HOME=%JAVA_HOME:"=%

#       There are tweaks for specific operating systems such as AIX, CygWin,

set JAVA_EXE=%JAVA_HOME%/bin/java.exe

#       Darwin, MinGW, and NonStop.

#

if exist "%JAVA_EXE%" goto execute

#   (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

echo.

#       within the Gradle project.

echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%

#

echo.

#       You can find Gradle at https://github.com/gradle/gradle/.

echo Please set the JAVA_HOME variable in your environment to match the

#

echo location of your Java installation.

##############################################################################

goto fail

# Attempt to set APP_HOME

:execute

# Resolve links: $0 may be a link

@rem Setup the command line

app_path=$0

set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar

# Need this for daisy-chained symlinks.

while

    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path

@rem Execute Gradle

    [ -h "$app_path" ]

"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*

do

    ls=$( ls -ld "$app_path" )

:end

    link=${ls#*' -> '}

@rem End local scope for the variables with windows NT shell

    case $link in             #(

if "%ERRORLEVEL%"=="0" goto mainEnd

      /*)   app_path=$link ;; #(

      *)    app_path=$APP_HOME$link ;;

:fail

    esac

rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of

done

rem the _cmd.exe /c_ return code!

if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1

# This is normally unused

exit /b 1

# shellcheck disable=SC2034

APP_BASE_NAME=${0##*/}

:mainEnd

APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit

if "%OS%"=="Windows_NT" endlocal

# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

:omega

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

+19
−22

Original line number
Original line
Diff line number
Diff line

import controller.Controller;

import controller.Controller;

import controller.Simulation;

import javafx.application.Application;

import javafx.application.Application;

import javafx.application.Platform;

import javafx.application.Platform;

import javafx.fxml.FXMLLoader;

import javafx.fxml.FXMLLoader;

import javafx.scene.Parent;

import javafx.scene.Parent;

import javafx.scene.Scene;

import javafx.scene.Scene;

import javafx.stage.Stage;

import javafx.stage.Stage;

import model.GameOfLife;

import model.CellularAutomatonSimulation;

import model.Grid;

import model.automata.GameOfLifeAutomaton;

import java.io.IOException;

import java.io.IOException;

import java.net.URL;

import java.net.URL;

import java.util.Random;

import static java.util.Objects.requireNonNull;

/**

/**

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

 * 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;

  public static final Random GENERATOR = new Random();

  private static final int NUMBER_OF_COLUMNS = 70;

  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 static final String VIEW_RESOURCE_PATH = "/view/view.fxml";

  private final GameOfLife gameOfLife;

  private final Simulation simulation;

  private Stage primaryStage;

  private Stage primaryStage;

  private Parent view;

  private Parent view;

  /**

  /**

   * Creates a new {@code GameOfLifeApplication} instance.

   * Creates a new {@code GameOfLifeApplication} instance.

   */

   */

  public GameOfLifeApplication() {

  public SimulatorApplication() {

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

    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

  @Override

  public void start(Stage primaryStage) throws IOException {

  public void start(Stage primaryStage) throws IOException {

@@ -63,11 +60,11 @@ public class GameOfLifeApplication extends Application {

  private void initializeView() throws IOException {

  private void initializeView() throws IOException {

    FXMLLoader loader = new FXMLLoader();

    FXMLLoader loader = new FXMLLoader();

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

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

    loader.setLocation(location);

    loader.setLocation(location);

    view = loader.load();

    view = loader.load();

    Controller controller = loader.getController();

    Controller controller = loader.getController();

    controller.setGameOfLife(gameOfLife);

    controller.setSimulation(simulation);

  }

  }

src/main/java/controller/Controller.java

+61
−19

Original line number
Original line
Diff line number
Diff line

package controller;

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.fxml.FXML;

import javafx.scene.control.Label;

import javafx.scene.control.Label;

import javafx.scene.control.ToggleButton;

import javafx.scene.control.ToggleButton;

import javafx.scene.control.ToggleGroup;

import javafx.scene.control.ToggleGroup;

import model.GameOfLife;

import javafx.util.Duration;

import model.Grid;

import view.MatrixPane;

import view.MatrixPane;

import static java.util.Objects.requireNonNull;

import static java.util.Objects.requireNonNull;

@@ -15,6 +20,7 @@ import static java.util.Objects.requireNonNull;

 */

 */

public class Controller {

public class Controller {

    public static final int PERIOD_IN_MILLISECONDS = 100;

    @FXML

    @FXML

    private ToggleButton playToggleButton;

    private ToggleButton playToggleButton;

    @FXML

    @FXML

@@ -23,12 +29,18 @@ public class Controller {

    private Label generationNumberLabel;

    private Label generationNumberLabel;

    @FXML

    @FXML

    private MatrixPane matrixPane;

    private MatrixPane matrixPane;

    private Timeline timeline;

    private GameOfLife gameOfLife;

    public Simulation getSimulation() {

        return simulation;

    }

    private Simulation simulation;

    @FXML

    @FXML

    private void initialize() {

    private void initialize() {

        initializePlayAndPauseToggleButtons();

        initializePlayAndPauseToggleButtons();

        updateTimeline();

    }

    }

    private void initializePlayAndPauseToggleButtons() {

    private void initializePlayAndPauseToggleButtons() {

@@ -38,47 +50,77 @@ public class Controller {

    }

    }

    /**

    public void setSimulation(Simulation simulation) {

     * Sets {@link GameOfLife} instance.

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

     *

     * @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");

        setGenerationNumberLabelTextProperty();

        setGenerationNumberLabelTextProperty();

        initializeMatrixPane();

        initializeMatrixPane();

    }

    }

    private void setGenerationNumberLabelTextProperty() {

    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() {

    private void initializeMatrixPane() {

        Grid grid = gameOfLife.getGrid();

        matrixPane.initialize(this);

        matrixPane.initialize(grid);

    }

    }

    @FXML

    @FXML

    private void playToggleButtonAction() {

    private void playToggleButtonAction() {

        gameOfLife.play();

        this.play();

    }

    }

    @FXML

    @FXML

    private void pauseToggleButtonAction() {

    private void pauseToggleButtonAction() {

        gameOfLife.pause();

        this.pause();

    }

    }

    @FXML

    @FXML

    private void resetButtonAction() {

    private void resetButtonAction() {

        gameOfLife.reset();

        this.pause();

        simulation.reset();

        pauseToggleButton.setSelected(true);

        pauseToggleButton.setSelected(true);

    }

    }

    @FXML

    @FXML

    private void clearButtonAction() {

    private void clearButtonAction() {

        gameOfLife.clear();

        this.pause();

        simulation.clear();

        pauseToggleButton.setSelected(true);

        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.java0 → 100644

+82
−0

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+16
−0

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+130
−0

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+44
−0

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+63
−0

Original line number
Original line
Diff line number
Diff line

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

  }

}

src/main/java/matrix/Matrix.java0 → 100644

+87
−0

Original line number
Original line
Diff line number
Diff line

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

  }

}

src/main/java/matrix/MatrixInitializer.java0 → 100644

+18
−0

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+27
−0

Original line number
Original line
Diff line number
Diff line

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

+31
−38

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import javafx.beans.property.Property;

import java.util.ArrayList;

import javafx.beans.property.SimpleObjectProperty;

import java.util.List;

/**

 * {@link Cell} instances represent the cells of <i>The Game of Life</i>.

 */

public class Cell {

    private final Property<CellState> stateProperty = new SimpleObjectProperty<>(CellState.DEAD);

/**

/**

     * Determines whether this {@link Cell} is alive or not.

 * A class representing a cell that holds a value and allows adding listeners to track value changes.

 *

 *

     * @return {@code true} if this {@link Cell} is alive and {@code false} otherwise

 * @param <T> The type of value stored in the cell.

 */

 */

public class Cell<T> implements Lens<T> {

    public boolean isAlive() {

    //TODO: ajouter la ou les propriétés nécessaires

        return getState().isAlive;

    }

    /**

    // la liste des objets écoutant les modifications du contenu de la cellule

     * Sets the state of this {@link Cell}.

    private final List<OnChangeListener<T>> listeners = new ArrayList<>();

    /** 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 Cell(T initialContent) {

    public void setState(CellState cellState) {

        //TODO: à compléter

        getStateProperty().setValue(cellState);

    }

    }

    /**

    /** Add a {@link OnChangeListener} to react to any change of value in the cell.

     * Returns the current state of this {@link 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 void addOnChangeListener(OnChangeListener<T> listener) {

    public CellState getState(){

        this.listeners.add(listener);

        return getStateProperty().getValue();

    }

    }

    /**

    /**

     * 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 set(T value) {

    public void toggleState() {

        //TODO: modifier le contenu de la cellule, puis appeler les méthodes valueChanged des

        CellState[] possibleStates = CellState.values();

        // listeners

        int stateOrdinal = getState().ordinal();

        int numberOfPossibleStates = possibleStates.length;

        setState(possibleStates[(stateOrdinal+1)%numberOfPossibleStates]);

    }

    }

    /**

    /**

     * 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() {

    public T get(){

        return stateProperty;

        //TODO: à compléter

        return null;

    }

    }

}

}

src/main/java/model/CellState.javadeleted100644 → 0

+0
−18

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+42
−0

Original line number
Original line
Diff line number
Diff line

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.java0 → 100644

+124
−0

Original line number
Original line
Diff line number
Diff line

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

    }

}

src/main/java/model/ConstantCellInitializer.java0 → 100644

+30
−0

Original line number
Original line
Diff line number
Diff line

package model;

import matrix.Coordinate;

import matrix.ListMatrix;

import matrix.MatrixInitializer;

/**

 *  An initializer for {@link ListMatrix} of {@link Cell}s, where each cell is initialized to the

 *  same value.

 *

 * @param <T> the type of content of each cell

 */

public class ConstantCellInitializer<T>  implements MatrixInitializer<Cell<T>> {

    //TODO: ajouter la/les propriétes nécessaires

    /** Make a new {@link MatrixInitializer} with cells containing a {@link Cell} with the same

     * value.

     *

     * @param defaultValue the value stored in each cell.

     */

    public ConstantCellInitializer(T defaultValue) {

        //TODO: à compléter

    }

    @Override

    public Cell<T> initialValueAt(Coordinate coordinate) {

        //TODO: à compléter

        return null;

    }

}

src/main/java/model/GameOfLife.javadeleted100644 → 0

+0
−115

Original line number
Original line
Diff line number
Diff line

package model;

import javafx.animation.Animation;

import javafx.animation.KeyFrame;

import javafx.animation.Timeline;

import javafx.beans.property.ReadOnlyLongProperty;

import javafx.beans.property.ReadOnlyLongWrapper;

import javafx.event.ActionEvent;

import javafx.event.EventHandler;

import javafx.util.Duration;

import java.util.Random;

import static java.util.Objects.requireNonNull;

/**

 * {@link GameOfLife} instances run <i>The Game of Life</i>.

 */

public class GameOfLife {

    private final Random random = new Random();

    private static final int PERIOD_IN_MILLISECONDS = 100;

    private final Grid grid;

    private final ReadOnlyLongWrapper generationNumber = new ReadOnlyLongWrapper();

    private Timeline timeline;

    /**

     * Creates a new {@code GameOfLife} instance given the underlying {@link Grid}.

     *

     * @param grid the underlying {@link Grid}

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

     */

    public GameOfLife(Grid grid) {

        this.grid = requireNonNull(grid, "grid is null");

        updateTimeline();

        grid.randomGeneration(random);

    }

    private void updateTimeline() {

        Duration duration = new Duration(PERIOD_IN_MILLISECONDS);

        EventHandler<ActionEvent> eventHandler = event -> next();

        KeyFrame keyFrame = new KeyFrame(duration, eventHandler);

        timeline = new Timeline(keyFrame);

        timeline.setCycleCount(Animation.INDEFINITE);

    }

    /**

     * Transitions into the next generationNumber.

     */

    private void next() {

        grid.updateToNextGeneration();

        generationNumber.set(getGenerationNumber() + 1);

    }

    /**

     * Returns the current generationNumber.

     *

     * @return the current generationNumber

     */

    private long getGenerationNumber() {

        return generationNumber.get();

    }

    /**

     * Returns the generationNumber {@link ReadOnlyLongProperty}.

     *

     * @return the generationNumber {@link ReadOnlyLongProperty}

     */

    public ReadOnlyLongProperty generationNumberProperty() {

        return generationNumber.getReadOnlyProperty();

    }

    /**

     * Returns the {@link Grid}.

     *

     * @return the {@link Grid}

     */

    public Grid getGrid() {

        return grid;

    }

    /**

     * Plays the game.

     */

    public void play() {

        timeline.play();

    }

    /**

     * Pauses the game.

     */

    public void pause() {

        timeline.pause();

    }

    /**

     * Clears the current game.

     */

    public void clear() {

        pause();

        grid.clear();

        generationNumber.set(0);

    }

    /**

     * Clears the current game and randomly generates a new one.

     */

    public void reset() {

        clear();

        grid.randomGeneration(random);

    }

}

src/main/java/model/Grid.javadeleted100644 → 0

+0
−156

Original line number
Original line
Diff line number
Diff line

package model;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

/**

 * {@link Grid} instances represent the grid in <i>The Game of Life</i>.

 */

public class Grid implements Iterable<Cell> {

    private final int numberOfRows;

    private final int numberOfColumns;

    private final Cell[][] cells;

    /**

     * Creates a new {@code Grid} instance given the number of rows and columns.

     *

     * @param numberOfRows    the number of rows

     * @param numberOfColumns the number of columns

     * @throws IllegalArgumentException if {@code numberOfRows} or {@code numberOfColumns} are

     *                                  less than or equal to 0

     */

    public Grid(int numberOfRows, int numberOfColumns) {

        this.numberOfRows = numberOfRows;

        this.numberOfColumns = numberOfColumns;

        this.cells = createCells();

    }

    /**

     * Returns an iterator over the cells in this {@code Grid}.

     *

     * @return an iterator over the cells in this {@code Grid}

     */

    @Override

    public Iterator<Cell> iterator() {

        return new GridIterator(this);

    }

    private Cell[][] createCells() {

        Cell[][] cells = new Cell[getNumberOfRows()][getNumberOfColumns()];

        for (int rowIndex = 0; rowIndex < getNumberOfRows(); rowIndex++) {

            for (int columnIndex = 0; columnIndex < getNumberOfColumns(); columnIndex++) {

                cells[rowIndex][columnIndex] = new Cell();

            }

        }

        return cells;

    }

    /**

     * Returns the {@link Cell} at the given index.

     *

     * <p>Note that the index is wrapped around so that a {@link Cell} is always returned.

     *

     * @param rowIndex    the row index of the {@link Cell}

     * @param columnIndex the column index of the {@link Cell}

     * @return the {@link Cell} at the given row and column index

     */

    public Cell getCell(int rowIndex, int columnIndex) {

        return cells[getWrappedRowIndex(rowIndex)][getWrappedColumnIndex(columnIndex)];

    }

    private int getWrappedRowIndex(int rowIndex) {

        return (rowIndex + getNumberOfRows()) % getNumberOfRows();

    }

    private int getWrappedColumnIndex(int columnIndex) {

        return (columnIndex + getNumberOfColumns()) % getNumberOfColumns();

    }

    /**

     * 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;

    }

    // TODO: Écrire une version correcte de cette méthode.

    public List<Cell> getNeighbors(int rowIndex, int columnIndex) {

        return null;

    }

    // TODO: Écrire une version correcte de cette méthode.

    public int countAliveNeighbors(int rowIndex, int columnIndex) {

        return 0;

    }

    // TODO: Écrire une version correcte de cette méthode.

    public CellState calculateNextState(int rowIndex, int columnIndex) {

        return null;

    }

    // TODO: Écrire une version correcte de cette méthode.

    public CellState[][] calculateNextStates() {

        CellState[][] nextCellState = new CellState[getNumberOfRows()][getNumberOfColumns()];

        return nextCellState;

    }

    // TODO: Écrire une version correcte de cette méthode.

    public void updateStates(CellState[][] nextState) {

    }

    /**

     * 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.

    void updateToNextGeneration() {

    }

    /**

     * Sets all {@link Cell}s in this {@code Grid} as dead.

     */

    // TODO: Écrire une version correcte de cette méthode.

    void clear() {

    }

    /**

     * Goes through each {@link Cell} in this {@code Grid} and randomly sets its state as ALIVE or DEAD.

     *

     * @param random {@link Random} instance used to decide if each {@link Cell} is ALIVE or DEAD.

     * @throws NullPointerException if {@code random} is {@code null}.

     */

    // TODO: Écrire une version correcte de cette méthode.

    void randomGeneration(Random random) {

    }

}

src/main/java/model/GridIterator.javadeleted100644 → 0

+0
−33

Original line number
Original line
Diff line number
Diff line

package model;

import java.util.Iterator;

/**

 * {@link GridIterator} instances are used to iterate over the cells of a grid.

 */

public class GridIterator implements Iterator<Cell> {

    private int rowIndex;

    private int columnIndex;

    private final Grid grid;

    GridIterator(Grid grid) {

        this.rowIndex = 0;

        this.columnIndex = 0;

        this.grid = grid;

    }

    @Override

    public boolean hasNext() {

        return columnIndex < grid.getNumberOfColumns() && rowIndex < grid.getNumberOfRows();

    }

    @Override

    public Cell next() {

        final Cell result = grid.getCell(rowIndex, columnIndex);

        columnIndex = (columnIndex +1) % grid.getNumberOfColumns();

        if(columnIndex == 0){

            rowIndex++;

        }

        return result;

    }

}

src/main/java/model/Lens.java0 → 100644

+22
−0

Original line number
Original line
Diff line number
Diff line

package model;

/**

 * A lens interface representing a view into a mutable state.

 *

 * @param <S> The type of the value stored in the lens.

 */

public interface Lens<S> {

    /**

     * Gets the value from the {@link Lens}.

     *

     * @return The value stored in the place designated by {@link Lens}.

     */

    S get();

    /**

     * Sets a new value into the {@link Lens}.

     *

     * @param value The new value to set in the place designated by the {@link Lens}.

     */

    void set(S value);

}

src/main/java/model/NextGenerationInitializer.java0 → 100644

+58
−0

Original line number
Original line
Diff line number
Diff line

package model;

import matrix.Coordinate;

import matrix.MatrixInitializer;

import matrix.ListMatrix;

import controller.Simulation;

/**

 * An initializer for a {@link ListMatrix} of states, where each state is computed based on the value

 * of its neighbours in a {@link Simulation} of a cellular automaton.

 *

 * @param <S> the type of states in the simulation.

 */

public class NextGenerationInitializer<S extends State<S>> implements MatrixInitializer<S> {

    //TODO: ajouter les propriétés nécessaires

    /** Create a {@link MatrixInitializer} to compute the next generation in

     * a 2D cellular automaton.

     *

     * @param simulation the {@link Simulation} representing the cellular automaton.

     */

    public NextGenerationInitializer(CellularAutomatonSimulation<S> simulation) {

        //TODO: à compléter

    }

    @Override

    public S initialValueAt(Coordinate coordinate) {

        //TODO: à compléter

        return null;

    }

    /** Computes the grid {@link Coordinate} for an arbitrary {@link Coordinate}, even outside

     * the grid. This is done by considering that the grid wraps over its edges, connecting the left side to the right

     * side, and the top side to the bottom side. This way, every cell has 4 orthogonal

     * neighbours and 4 diagonal neighbours.

     *

     * @param coordinate a {@link Coordinate} that may be outside the grid.

     * @return a corresponding {@link Coordinate}, that is inside the grid.

     */

    Coordinate wrap(Coordinate coordinate) {

        //TODO: à compléter

        //Il faut recalculer les coordonnées x et y modulo les dimensions de la grille.

        //Pour le modulo, utiliser la fonction ci-dessous, qui s'assure que le résultat est positif.

        return null;

    }

    /** The non-negative remainder of n divided by d.

     *

     * @param n an arbitrary integer.

     * @param d a non-zero integer.

     * @return the remainder of {@code n/d}, between {@code 0} and {@code n-1}.

     */

    static int modulo(int n, int d) {

        int result = n % d;

        return n < 0 ? result + d : result;

    }

}

src/main/java/model/OnChangeListener.java0 → 100644

+5
−0

Original line number
Original line
Diff line number
Diff line

package model;

public interface OnChangeListener<T> {

    void valueChanged(T oldValue, T newValue);

}

src/main/java/model/State.java0 → 100644

+50
−0

Original line number
Original line
Diff line number
Diff line

package model;

import javafx.scene.paint.Color;

import java.util.List;

/**

 * Represents a state of a cell in a cellular automaton, and the update rules for the cellular

 * automaton.

 *

 * @param <S> The type of the state itself, used for reflexivity: if a class {@code SomeState}

 *          wants to implement this interface, it should implement {@code State<SomeState>}.

 */

public interface State<S> {

    /**

     * Returns the color associated with this state.

     *

     * @return The color representing this state.

     */

    Color getColor();

    /**

     * Computes and returns the next state based on the rules of the cellular automaton.

     *

     * @return The next state.

     */

    S next();

    /**

     * Updates the state based on the states of its neighboring cells.

     *

     * @param neighbours A list of neighboring cell states.

     * @return The updated state based on the neighbors.

     */

    S update(List<S> neighbours);

    /**

     * Counts the occurrences of a specific state within a list of neighboring states.

     *

     * @param <T>       The type of state to count.

     * @param state     The state to count occurrences of.

     * @param neighbours A list of neighboring states to search within.

     * @return The number of times the specified state appears in the list of neighbors.

     */

    static <T> int count(T state, List<T> neighbours) {

        //TODO: à compléter

        return 0;

    }

}

 No newline at end of file

src/main/java/model/automata/GameOfLifeAutomaton.java0 → 100644

+36
−0

Original line number
Original line
Diff line number
Diff line

package model.automata;

import model.CellularAutomaton;

import java.util.Random;

public class GameOfLifeAutomaton implements CellularAutomaton<GameOfLifeState> {

    public GameOfLifeAutomaton(int numberOfColumns, int numberOfRows) {

        //TODO: à compléter

    }

    @Override

    public int numberOfColumns() {

        //TODO: à compléter

        return 0;

    }

    @Override

    public int numberOfRows() {

        //TODO: à compléter

        return 0;

    }

    @Override

    public GameOfLifeState defaultState() {

        //TODO: à compléter

        return null;

    }

    @Override

    public GameOfLifeState randomState(Random generator) {

        //TODO: à compléter

        return null;

    }

}

src/main/java/model/automata/GameOfLifeState.java0 → 100644

+33
−0

Original line number
Original line
Diff line number
Diff line

package model.automata;

import javafx.scene.paint.Color;

import model.State;

import java.util.List;

/**

 * {@link GameOfLifeState} instances represent the possible states of a {@link GameOfLifeState}.

 */

public enum GameOfLifeState implements State<GameOfLifeState> {

    ALIVE, DEAD;

    @Override

    public Color getColor() {

        //TODO: à compléter

        return Color.BLACK;

    }

    @Override

    public GameOfLifeState next() {

        //TODO: à compléter

        return null;

    }

    @Override

    public GameOfLifeState update(List<GameOfLifeState> neighbours) {

        //TODO: à compléter

        return null;

    }

}

src/main/java/view/FillingMouseListener.java0 → 100644

+38
−0

Original line number
Original line
Diff line number
Diff line

package view;

import matrix.Coordinate;

import javafx.scene.input.MouseEvent;

public class FillingMouseListener implements MouseListener {

    private final MatrixPane matrix;

    private final Coordinate source;

    public FillingMouseListener(MatrixPane matrix, Coordinate source) {

        this.matrix = matrix;

        this.source = source;

    }

    @Override

    public void onMouseReleased(MouseEvent event, Coordinate coordinate) {

        this.matrix.resetWaitingListener();

    }

    @Override

    public void onMouseEntered(MouseEvent event, Coordinate destination) {

        if (!event.isPrimaryButtonDown()) {

            this.matrix.resetWaitingListener();

            return;

        }

        this.matrix.getController().getSimulation().copy(source, destination);

    }

    @Override

    public void onMousePressed(MouseEvent event, Coordinate coordinate) {

        this.matrix.getController().getSimulation().next(coordinate);

        this.matrix.setMouseListener(

                new FillingMouseListener(this.matrix, coordinate)

        );

    }

}

src/main/java/view/MatrixPane.java

+60
−21

Original line number
Original line
Diff line number
Diff line

package view;

package view;

import controller.Controller;

import matrix.Coordinate;

import javafx.scene.input.MouseDragEvent;

import javafx.scene.input.MouseEvent;

import javafx.scene.input.MouseEvent;

import javafx.scene.layout.GridPane;

import javafx.scene.layout.GridPane;

import javafx.scene.paint.Color;

import javafx.scene.shape.Rectangle;

import javafx.scene.shape.Rectangle;

import model.Cell;

import model.CellState;

import model.Grid;

/**

/**

 * Created by Arnaud Labourel on 22/11/2018.

 * Created by Arnaud Labourel on 22/11/2018.

@@ -13,32 +14,70 @@ import model.Grid;

public class MatrixPane extends GridPane {

public class MatrixPane extends GridPane {

    private static final double CELL_SIZE = 14;

    private static final double CELL_SIZE = 14;

    public void initialize(Grid grid) {

    public Controller getController() {

        for (int rowIndex = 0; rowIndex < grid.getNumberOfRows(); rowIndex++) {

        return controller;

            for (int columnIndex = 0; columnIndex < grid.getNumberOfColumns(); columnIndex++) {

                addCellRectangle(grid.getCell(rowIndex,columnIndex), rowIndex, columnIndex);

    }

    }

    private Controller controller;

    public void initialize(Controller controller) {

        this.controller = controller;

        for (Coordinate coordinate : controller.coordinates()) {

            addCellRectangle(coordinate);

        }

        }

    }

    }

    private void addCellRectangle(Cell cell, int rowIndex, int columnIndex) {

    private void addCellRectangle(Coordinate coord) {

        Rectangle rectangleCell = new Rectangle(CELL_SIZE, CELL_SIZE);

        Rectangle rectangleCell = new Rectangle(CELL_SIZE, CELL_SIZE);

        addStatePropertyListener(cell, rectangleCell);

        addStatePropertyListener(rectangleCell, coord);

        updateFill(rectangleCell, cell.getState());

        updateFill(rectangleCell, coord);

        addClickEventHandler(cell, rectangleCell);

        addEventHandler(rectangleCell, coord);

        add(rectangleCell, columnIndex, rowIndex);

        add(rectangleCell, coord);

    }

    private void add(Rectangle rectangleCell, Coordinate coord) {

        this.add(rectangleCell, coord.x(), coord.y());

    }

    private void addStatePropertyListener(Rectangle cellRectangle, Coordinate coord) {

        controller.getSimulation().setChangeListener(

                coord,

                () -> updateFill(cellRectangle, coord)

        );

    }

    }

    private void addStatePropertyListener(Cell cell, Rectangle cellRectangle) {

    private void updateFill(Rectangle cellRectangle, Coordinate coord) {

        cell.getStateProperty().addListener((observable, oldValue, newValue) ->

        Color color = this.controller.getSimulation().getColor(coord);

                updateFill(cellRectangle, newValue));

        cellRectangle.setFill(color);

    }

    }

    private void updateFill(Rectangle cellRectangle, CellState newCellState) {

    private void addEventHandler(Rectangle cellRectangle, Coordinate coord) {

        cellRectangle.setFill(newCellState.color);

        cellRectangle.addEventHandler(

                MouseEvent.MOUSE_PRESSED,

                event -> mouseListener.onMousePressed(event, coord)

        );

        cellRectangle.addEventHandler(

                MouseEvent.DRAG_DETECTED,

                event -> this.startFullDrag()

        );

        cellRectangle.addEventHandler(

                MouseDragEvent.MOUSE_DRAG_RELEASED,

                event -> mouseListener.onMouseReleased(event, coord)

        );

        cellRectangle.addEventHandler(

                MouseDragEvent.MOUSE_DRAG_ENTERED,

                event -> mouseListener.onMouseEntered(event, coord)

        );

    }

    private MouseListener mouseListener = new WaitingMouseListener(this);

    void setMouseListener(MouseListener mouseListener) {

        this.mouseListener = mouseListener;

    }

    }

    private void addClickEventHandler(Cell cell, Rectangle cellRectangle) {

    void resetWaitingListener() {

        cellRectangle.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> cell.toggleState());

        this.mouseListener = new WaitingMouseListener(this);

    }

    }

}

}

src/main/java/view/MouseListener.java0 → 100644

+13
−0

Original line number
Original line
Diff line number
Diff line

package view;

import matrix.Coordinate;

import javafx.scene.input.MouseEvent;

interface MouseListener {

    default void onMousePressed(MouseEvent event, Coordinate coordinate) {}

    default void onMouseReleased(MouseEvent event, Coordinate coordinate) {}

    default void onMouseEntered(MouseEvent event, Coordinate coordinate) {};

}

src/main/java/view/WaitingMouseListener.java0 → 100644

+22
−0

Original line number
Original line
Diff line number
Diff line

package view;

import matrix.Coordinate;

import javafx.scene.input.MouseEvent;

class WaitingMouseListener implements MouseListener {

    private final MatrixPane matrix;

    WaitingMouseListener(MatrixPane matrix) {

        this.matrix = matrix;

    }

    @Override

    public void onMousePressed(MouseEvent event, Coordinate coordinate) {

        this.matrix.getController().getSimulation().next(coordinate);

        this.matrix.setMouseListener(new FillingMouseListener(this.matrix, coordinate));

    }

}

src/main/resources/view/view.fxml

+2
−8

Original line number
Original line
Diff line number
Diff line

<?xml version="1.0" encoding="UTF-8"?>

<?xml version="1.0" encoding="UTF-8"?>

<?import javafx.geometry.Insets?>

<?import javafx.geometry.Insets?>

<?import javafx.scene.control.Button?>

<?import javafx.scene.control.*?>

<?import javafx.scene.control.Label?>

<?import javafx.scene.layout.*?>

<?import javafx.scene.control.Separator?>

<?import javafx.scene.control.ToggleButton?>

<?import javafx.scene.layout.AnchorPane?>

<?import javafx.scene.layout.GridPane?>

<?import javafx.scene.layout.HBox?>

<?import view.MatrixPane?>

<?import view.MatrixPane?>

<AnchorPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308"

<AnchorPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308"

            styleClass="background" stylesheets="@style.css"

            styleClass="background" stylesheets="@style.css"

src/test/java/matrix/ConstantMatrixInitializerTest.java0 → 100644

+31
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class ConstantMatrixInitializerTest {

    @Test

    public void testMatrixInitializationWithConstantValue() {

        ListMatrix<String> matrix = new ListMatrix<>(3, 3, new ConstantMatrixInitializer<>("X"));

        // Test that all cells have the constant value.

        for (int x = 0; x < 3; x++) {

            for (int y = 0; y < 3; y++) {

                assertEquals("X", matrix.get(x, y));

            }

        }

    }

    @Test

    public void testMatrixInitializationWithConstantValue2() {

        ListMatrix<Integer> matrix = new ListMatrix<>(3, 5, new ConstantMatrixInitializer<>(12));

        // Test that all cells have the constant value.

        for (int x = 0; x < 3; x++) {

            for (int y = 0; y < 5; y++) {

                assertEquals(12, matrix.get(x, y));

            }

        }

    }

}

 No newline at end of file

src/test/java/matrix/CoordinateIteratorTest.java0 → 100644

+53
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import java.util.NoSuchElementException;

import static org.junit.jupiter.api.Assertions.*;

class CoordinateIteratorTest {

    @Test

    public void testIteratorWithZeroDimensions() {

        CoordinateIterator iterator = new CoordinateIterator(0, 0);

        assertFalse(iterator.hasNext());

    }

    @Test

    public void testIteratorWithOneDimension() {

        CoordinateIterator iterator = new CoordinateIterator(5, 1);

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(0, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(1, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(2, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(3, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(4, 0), iterator.next());

        assertFalse(iterator.hasNext());

        assertThrows(NoSuchElementException.class, iterator::next);

    }

    @Test

    public void testIteratorWithTwoDimensions() {

        CoordinateIterator iterator = new CoordinateIterator(3, 2);

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(0, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(1, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(2, 0), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(0, 1), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(1, 1), iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(Coordinate.of(2, 1), iterator.next());

        assertFalse(iterator.hasNext());

        assertThrows(NoSuchElementException.class, iterator::next);

    }

}

 No newline at end of file

src/test/java/matrix/CoordinateTest.java0 → 100644

+100
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

public class CoordinateTest {

    @Test

    public void testCoordinateCreation() {

        Coordinate coordinate = Coordinate.of(3, 4);

        assertEquals(3, coordinate.x());

        assertEquals(4, coordinate.y());

    }

    @Test

    public void testLeft() {

        Coordinate coordinate = Coordinate.of(3, 4);

        Coordinate left = coordinate.left();

        assertEquals(2, left.x());

        assertEquals(4, left.y());

    }

    @Test

    public void testRight() {

        Coordinate coordinate = Coordinate.of(3, 4);

        Coordinate right = coordinate.right();

        assertEquals(4, right.x());

        assertEquals(4, right.y());

    }

    @Test

    public void testAbove() {

        Coordinate coordinate = Coordinate.of(3, 4);

        Coordinate above = coordinate.above();

        assertEquals(3, above.x());

        assertEquals(5, above.y());

    }

    @Test

    public void testBelow() {

        Coordinate coordinate = Coordinate.of(3, 4);

        Coordinate below = coordinate.below();

        assertEquals(3, below.x());

        assertEquals(3, below.y());

    }

    @Test

    public void testOrthogonalNeighbours() {

        Coordinate coordinate = Coordinate.of(3, 4);

        List<Coordinate> neighbours = coordinate.orthogonalNeighbours();

        assertEquals(4, neighbours.size());

        assertTrue(neighbours.contains(Coordinate.of(2, 4)));

        assertTrue(neighbours.contains(Coordinate.of(4, 4)));

        assertTrue(neighbours.contains(Coordinate.of(3, 3)));

        assertTrue(neighbours.contains(Coordinate.of(3, 5)));

        assertFalse(neighbours.contains(coordinate));

        assertFalse(neighbours.contains(Coordinate.of(1, 4)));

        assertFalse(neighbours.contains(Coordinate.of(5, 4)));

        assertFalse(neighbours.contains(Coordinate.of(3, 6)));

        assertFalse(neighbours.contains(Coordinate.of(3, 1)));

    }

    @Test

    public void testDiagonalNeighbours() {

        Coordinate coordinate = Coordinate.of(3, 4);

        List<Coordinate> neighbours = coordinate.diagonalNeighbours();

        assertEquals(4, neighbours.size());

        assertTrue(neighbours.contains(Coordinate.of(2, 3)));

        assertTrue(neighbours.contains(Coordinate.of(4, 3)));

        assertTrue(neighbours.contains(Coordinate.of(2, 5)));

        assertTrue(neighbours.contains(Coordinate.of(4, 5)));

        assertFalse(neighbours.contains(coordinate));

        assertFalse(neighbours.contains(Coordinate.of(1, 4)));

        assertFalse(neighbours.contains(Coordinate.of(5, 4)));

        assertFalse(neighbours.contains(Coordinate.of(3, 6)));

        assertFalse(neighbours.contains(Coordinate.of(3, 1)));

    }

    @Test

    public void testOrthodiagonalNeighbours() {

        Coordinate coordinate = Coordinate.of(3, 4);

        List<Coordinate> neighbours = coordinate.orthodiagonalNeighbours();

        assertEquals(8, neighbours.size());

        assertTrue(neighbours.contains(Coordinate.of(2, 4)));

        assertTrue(neighbours.contains(Coordinate.of(4, 4)));

        assertTrue(neighbours.contains(Coordinate.of(3, 3)));

        assertTrue(neighbours.contains(Coordinate.of(3, 5)));

        assertTrue(neighbours.contains(Coordinate.of(2, 3)));

        assertTrue(neighbours.contains(Coordinate.of(4, 3)));

        assertTrue(neighbours.contains(Coordinate.of(2, 5)));

        assertTrue(neighbours.contains(Coordinate.of(4, 5)));

        assertFalse(neighbours.contains(coordinate));

        assertFalse(neighbours.contains(Coordinate.of(1, 4)));

        assertFalse(neighbours.contains(Coordinate.of(5, 4)));

        assertFalse(neighbours.contains(Coordinate.of(3, 6)));

        assertFalse(neighbours.contains(Coordinate.of(3, 1)));

    }

}

 No newline at end of file

src/test/java/matrix/ListMatrixTest.java0 → 100644

+100
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import java.util.Iterator;

import static org.junit.jupiter.api.Assertions.*;

class ListMatrixTest {

    private final MatrixInitializer<Integer> sumInitializer =

            coord -> coord.x() + coord.y();

    @Test

    public void testMatrixCreationWithInitializer() {

        ListMatrix<Integer> matrix = new ListMatrix<>(3, 4, sumInitializer);

        assertEquals(3, matrix.width());

        assertEquals(4, matrix.height());

        assertEquals(4, matrix.get(2, 2));

        assertEquals(3, matrix.get(1, 2));

        assertEquals(3, matrix.get(2, 1));

        assertEquals(2, matrix.get(1, 1));

    }

    @Test

    public void testMatrixCreationWithInitialValue() {

        ListMatrix<String> matrix = new ListMatrix<>(2, 2, "Foo");

        assertEquals(2, matrix.width());

        assertEquals(2, matrix.height());

        assertEquals("Foo", matrix.get(1, 1)); // Test a specific cell value.

    }

    @Test

    public void testMatrixSetAndGet() {

        ListMatrix<Integer> matrix = new ListMatrix<>(3, 3, 0);

        matrix.set(1, 1,42);

        assertEquals(42, matrix.get(1, 1));

        matrix.set(0, 2,10);

        assertEquals(10, matrix.get(0, 2));

        matrix.set(Coordinate.of(2, 2),99);

        assertEquals(99, matrix.get(Coordinate.of(2, 2)));

    }

    @Test

    public void testMatrixWidthAndHeight() {

        ListMatrix<String> matrix = new ListMatrix<>(4, 2, "A");

        assertEquals(4, matrix.width());

        assertEquals(2, matrix.height());

        matrix.set(3, 1,"B");

        assertEquals(4, matrix.width());

        assertEquals(2, matrix.height());

    }

    @Test

    public void testMatrixIterator() {

        ListMatrix<Integer> matrix = new ListMatrix<>(2, 2, sumInitializer);

        Iterator<Integer> iterator = matrix.iterator();

        assertTrue(iterator.hasNext());

        assertEquals(0, iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(1, iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(1, iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(2, iterator.next());

        assertFalse(iterator.hasNext());

    }

    @Test

    public void testMatrixCoordinates() {

        ListMatrix<Integer> matrix = new ListMatrix<>(2, 2, 0);

        Iterable<Coordinate> coordinates = matrix.coordinates();

        int count = 0;

        for (Coordinate coord : coordinates) {

            count++;

        }

        assertEquals(4, count);

    }

    @Test

    public void testSubMatrix() {

      Matrix<Integer> matrix = new ListMatrix<>(5, 5, 0);

      for (int x = 0; x < 5; x++) {

        for (int y = 0; y < 5; y++) {

          matrix.set(x,y,x + y * 5);

        }

      }

      Matrix<Integer> sub = matrix.subMatrix(Coordinate.of(2,1),2,3);

      assertEquals(2, sub.width());

      assertEquals(3, sub.height());

      for (int x = 2; x < 4; x++) {

        for (int y = 1; y < 4; y++) {

          assertEquals(x + y * 5, sub.get(x-2,y-1));

        }

      }

    }

}

src/test/java/model/CellTest.java0 → 100644

+40
−0

Original line number
Original line
Diff line number
Diff line

package model;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class CellTest {

    private record Change<T>(T oldValue, T newValue) {}

    private static class MockListener<T> implements OnChangeListener<T> {

        private Change<T> lastChange = null;

        public boolean checksLastChange(T oldValue, T newValue) {

            return this.lastChange != null

                    && this.lastChange.oldValue.equals(oldValue)

                    && this.lastChange.newValue.equals(newValue);

        }

        @Override

        public void valueChanged(T oldValue, T newValue) {

            lastChange = new Change<>(oldValue, newValue);

        }

    }

    @Test

    public void testCellValueChangeWithListener() {

        Cell<Integer> cell = new Cell<>(42);

        MockListener<Integer> mockListener = new MockListener<>();

        cell.addOnChangeListener(mockListener);

        cell.set(99);

        assertTrue(mockListener.checksLastChange(42, 99));

        assertEquals(99, cell.get());

    }

    @Test

    public void testCellWithoutListener() {

        Cell<String> cell = new Cell<>("Foo");

        cell.set("Bar");

        assertEquals("Bar", cell.get());

    }

}

 No newline at end of file

src/test/java/model/CellularAutomatonSimulationTest.java0 → 100644

+162
−0

Original line number
Original line
Diff line number
Diff line

package model;

import matrix.Coordinate;

import javafx.scene.paint.Color;

import model.automata.GameOfLifeAutomaton;

import static model.automata.GameOfLifeState.*;

import model.automata.GameOfLifeState;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

import static org.junit.jupiter.api.Assertions.*;

class CellularAutomatonSimulationTest {

    private final CellularAutomatonSimulation<GameOfLifeState> simulation;

    private final CellularAutomaton<GameOfLifeState> automaton;

    private final Random randomGenerator;

    CellularAutomatonSimulationTest() {

        this.randomGenerator = new Random();

        this.automaton = new GameOfLifeAutomaton(4,3);

        this.simulation = new CellularAutomatonSimulation<>(automaton, randomGenerator);

    }

    @BeforeEach

    public void setUp() {

        this.simulation.clear();

    }

    @Test

    public void testNumberOfColumns() {

        assertEquals(4, simulation.numberOfColumns());

    }

    @Test

    public void testNumberOfRows() {

        assertEquals(3, simulation.numberOfRows());

    }

    @Test

    public void testAt() {

        Coordinate coordinate = Coordinate.of(1, 2);

        Cell<GameOfLifeState> cell = simulation.at(coordinate);

        assertEquals(DEAD,cell.get());

    }

    @Test

    public void testUpdateToNextGeneration() {

        GameOfLifeState[][] input =

                { {ALIVE, ALIVE, ALIVE, DEAD},

                  {ALIVE, DEAD, DEAD, DEAD},

                  {DEAD, ALIVE, DEAD, DEAD}

                };

        GameOfLifeState[][] output =

                { {ALIVE, DEAD, ALIVE, ALIVE},

                  {ALIVE, DEAD, ALIVE, ALIVE},

                  {DEAD, DEAD, ALIVE, ALIVE}

                };

        for (Coordinate coordinate : this.simulation) {

            this.simulation.at(coordinate).set(input[coordinate.y()][coordinate.x()]);

        }

        simulation.updateToNextGeneration();

        for (Coordinate coordinate : this.simulation) {

            assertEquals(

                    output[coordinate.y()][coordinate.x()],

                    this.simulation.at(coordinate).get(),

                    "Generation at " + coordinate

            );

        }

    }

    @Test

    public void testNext() {

        Coordinate coordinate = Coordinate.of(1, 1);

        Cell<GameOfLifeState> cell = simulation.at(coordinate);

        GameOfLifeState oldState = cell.get();

        simulation.next(coordinate);

        assertNotEquals(oldState, cell.get());

    }

    @Test

    public void testCopy() {

        Coordinate source = Coordinate.of(1, 1);

        Coordinate destination = Coordinate.of(2, 2);

        this.simulation.at(source).set(ALIVE);

        simulation.copy(source, destination);

        assertEquals(

                ALIVE,

                this.simulation.at(destination).get()

        );

    }

    @Test

    public void testColor() {

        Coordinate coordinate = Coordinate.of(1, 1);

        assertEquals(Color.WHITE, this.simulation.getColor(coordinate));

        this.simulation.at(coordinate).set(ALIVE);

        assertEquals(Color.RED, this.simulation.getColor(coordinate));

    }

    @Test

    public void testSetChangeListener() {

        Coordinate coordinate = Coordinate.of(1, 1);

        Coordinate otherCoordinate = Coordinate.of(0,2);

        Cell<GameOfLifeState> cell = simulation.at(coordinate);

        List<GameOfLifeState> states = new ArrayList<>();

        Runnable listener = () -> states.add(this.simulation.at(coordinate).get());

        simulation.setChangeListener(coordinate, listener);

        this.simulation.at(otherCoordinate).set(ALIVE);

        assertEquals(Collections.emptyList(), states);

        this.simulation.at(coordinate).set(ALIVE);

        this.simulation.at(otherCoordinate).set(DEAD);

        assertEquals(List.of(ALIVE), states);

        this.simulation.at(coordinate).set(ALIVE);

        this.simulation.at(otherCoordinate).set(ALIVE);

        this.simulation.at(coordinate).set(DEAD);

        assertEquals(List.of(ALIVE, ALIVE, DEAD), states);

    }

    @Test

    public void testSetGenerationNumberChangeListener() {

        List<Integer> values = new ArrayList<>();

        OnChangeListener<Integer> listener = (oldValue, newValue) -> values.add(newValue);

        simulation.setGenerationNumberChangeListener(listener);

        assertEquals(Collections.emptyList(), values);

        simulation.clear();

        assertEquals(List.of(0), values);

        simulation.updateToNextGeneration();

        assertEquals(List.of(0,1), values);

        simulation.updateToNextGeneration();

        simulation.updateToNextGeneration();

        assertEquals(List.of(0,1,2,3), values);

    }

    @Test

    public void testClear() {

        for (Coordinate coordinate : this.simulation) {

            this.simulation.at(coordinate).set(ALIVE);

        }

        this.simulation.clear();

        for (Coordinate coordinate : this.simulation) {

            assertEquals(DEAD, this.simulation.at(coordinate).get());

        }

    }

    @Test

    public void testReset() {

        randomGenerator.setSeed(321);

        this.simulation.reset();

        int count = 0;

        for (Coordinate coordinate : this.simulation) {

            if (this.simulation.at(coordinate).get().equals(ALIVE)) {

                count = count + 1;

            }

        }

        assertEquals(7, count);

    }

}

 No newline at end of file

src/test/java/model/GridTest.javadeleted100644 → 0

+0
−38

Original line number
Original line
Diff line number
Diff line

package model;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class GridTest {

  private Grid grid;

  @BeforeEach

  public void initializeGrid(){

    grid = new Grid(3,3);

  }

  @Test

  public void testGetNeighbors(){

    assertThat(grid.getNeighbors(1,1)).isNotNull();

    assertThat(grid.getNeighbors(1,1)).hasSize(8);

    assertThat(grid.getNeighbors(1,1))

            .containsExactlyInAnyOrder(grid.getCell(0,0),

                    grid.getCell(0,1),

                    grid.getCell(0,2),

                    grid.getCell(1,0),

                    grid.getCell(1,2),

                    grid.getCell(2,0),

                    grid.getCell(2,1),

                    grid.getCell(2,2));

  }

  @Test

  public void testCountAliveNeighbors(){

    assertThat(grid.countAliveNeighbors(1,1)).isEqualTo(0);

    grid.getCell(2,2).setState(CellState.ALIVE);

    grid.getCell(0,0).setState(CellState.ALIVE);

    assertThat(grid.countAliveNeighbors(1,1)).isEqualTo(2);

  }

}

src/test/java/model/NextGenerationInitializerTest.java0 → 100644

+81
−0

Original line number
Original line
Diff line number
Diff line

package model;

import matrix.Coordinate;

import model.automata.GameOfLifeAutomaton;

import model.automata.GameOfLifeState;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import java.util.Random;

import static model.automata.GameOfLifeState.ALIVE;

import static model.automata.GameOfLifeState.DEAD;

import static org.junit.jupiter.api.Assertions.*;

class NextGenerationInitializerTest {

    private final CellularAutomatonSimulation<GameOfLifeState> simulation =

            new CellularAutomatonSimulation<>(

                    new GameOfLifeAutomaton(4,3),

                    new Random()

                    );

    private final NextGenerationInitializer<GameOfLifeState> initializer =

            new NextGenerationInitializer<>(this.simulation);

    @BeforeEach

    public void prepareSimulation() {

        GameOfLifeState[][] state =

                { { DEAD, DEAD, DEAD, DEAD }

                , { ALIVE, ALIVE, DEAD, DEAD }

                , { DEAD, DEAD, ALIVE, DEAD }

                };

        for (Coordinate coordinate : this.simulation) {

            this.simulation.at(coordinate).set(state[coordinate.y()][coordinate.x()]);

        }

    }

    @Test

    void initialValueAt() {

        assertEquals(DEAD, initializer.initialValueAt(Coordinate.of(0,1)));

        assertEquals(ALIVE, initializer.initialValueAt(Coordinate.of(1,0)));

        assertEquals(ALIVE, initializer.initialValueAt(Coordinate.of(1,1)));

        assertEquals(ALIVE, initializer.initialValueAt(Coordinate.of(1,2)));

        assertEquals(DEAD, initializer.initialValueAt(Coordinate.of(2,2)));

    }

    @Test

    public void testWrapCoordinateInsideGrid() {

        Coordinate coordinate = Coordinate.of(1, 1);

        Coordinate wrapped = initializer.wrap(coordinate);

        assertEquals(coordinate, wrapped);

    }

    @Test

    public void testWrapCoordinateOutsideGrid() {

        assertEquals(

                Coordinate.of(0, 1),

                initializer.wrap(Coordinate.of(4, 4))

        );

        assertEquals(

                Coordinate.of(3, 2),

                initializer.wrap(Coordinate.of(-1, 2))

        );

         assertEquals(

                Coordinate.of(3, 2),

                initializer.wrap(Coordinate.of(-1, -1))

        );   }

    @Test

    public void testModuloPositive() {

        int result = NextGenerationInitializer.modulo(7, 4);

        assertEquals(3, result);

    }

    @Test

    public void testModuloNegative() {

        int result = NextGenerationInitializer.modulo(-7, 4);

        assertEquals(1, result);

    }

}

 No newline at end of file

src/test/java/model/StateTest.java0 → 100644

+39
−0

Original line number
Original line
Diff line number
Diff line

package model;

import org.junit.jupiter.api.Test;

import java.util.List;

import static model.State.count;

import static org.junit.jupiter.api.Assertions.*;

class StateTest {

    @Test

    public void testCountMethodWithInteger() {

        List<Integer> neighbours = List.of(1, 2, 1, 3, 1);

        int result = count(1, neighbours);

        assertEquals(3, result);

    }

    @Test

    public void testCountMethodWithString() {

        List<String> neighbours = List.of("apple", "banana", "apple", "cherry", "apple");

        int result = count("apple", neighbours);

        assertEquals(3, result);

    }

    @Test

    public void testCountMethodWithEmptyList() {

        List<Double> neighbours = List.of();

        int result = count(5.0, neighbours);

        assertEquals(0, result);

    }

    @Test

    public void testCountMethodWithNoMatchingElements() {

        List<Character> neighbours = List.of('a', 'b', 'c');

        int result = count('x', neighbours);

        assertEquals(0, result);

    }

}

 No newline at end of file

src/test/java/model/automata/GameOfLifeStateTest.java0 → 100644

+70
−0

Original line number
Original line
Diff line number
Diff line

package model.automata;

import javafx.scene.paint.Color;

import model.State;

import org.junit.jupiter.api.Test;

import java.util.List;

import static model.automata.GameOfLifeState.*;

import static org.junit.jupiter.api.Assertions.*;

class GameOfLifeStateTest {

    @Test

    public void testGetColor() {

        assertEquals(Color.WHITE, DEAD.getColor());

        assertEquals(Color.RED, ALIVE.getColor());

    }

    @Test

    public void testNext() {

        assertEquals(ALIVE.next(), DEAD);

        assertEquals(DEAD.next(), ALIVE);

    }

    @Test

    public void testAliveUpdate() {

        // Test with three alive neighbors, should be ALIVE

        List<GameOfLifeState> aliveNeighbors =

                List.of(ALIVE, DEAD, ALIVE, DEAD, ALIVE);

        assertEquals(ALIVE, ALIVE.update(aliveNeighbors));

        // Test with two alive neighbors, should be ALIVE

        List<GameOfLifeState> twoAliveNeighbors =

                List.of(ALIVE, DEAD, ALIVE, DEAD, DEAD);

        assertEquals(ALIVE, ALIVE.update(twoAliveNeighbors));

        // Test with four alive neighbors, should be DEAD

        List<GameOfLifeState> fourAliveNeighbors =

                List.of(ALIVE, ALIVE, DEAD, ALIVE, ALIVE);

        assertEquals(DEAD, ALIVE.update(fourAliveNeighbors));

        // Test with zero alive neighbors, should be DEAD

        List<GameOfLifeState> zeroAliveNeighbors =

                List.of(DEAD, DEAD, DEAD, DEAD);

        assertEquals(DEAD, ALIVE.update(zeroAliveNeighbors));

    }

    @Test

    public void testDeadUpdate() {

        // Test with three alive neighbors, should be ALIVE

        List<GameOfLifeState> aliveNeighbors =

                List.of(ALIVE, DEAD, ALIVE, DEAD, ALIVE);

        assertEquals(ALIVE, DEAD.update(aliveNeighbors));

        // Test with two alive neighbors, should be DEAD

        List<GameOfLifeState> twoAliveNeighbors =

                List.of(ALIVE, DEAD, ALIVE, DEAD, DEAD);

        assertEquals(DEAD, DEAD.update(twoAliveNeighbors));

        // Test with four alive neighbors, should be DEAD

        List<GameOfLifeState> fourAliveNeighbors =

                List.of(ALIVE, ALIVE, DEAD, ALIVE, ALIVE);

        assertEquals(DEAD, DEAD.update(fourAliveNeighbors));

        // Test with zero alive neighbors, should be DEAD

        List<GameOfLifeState> zeroAliveNeighbors =

                List.of(DEAD, DEAD, DEAD, DEAD);

        assertEquals(DEAD, DEAD.update(zeroAliveNeighbors));

    }

}

 No newline at end of file

Source

Target

Files