Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision

Target

Select target project
  • s20026898/tp-6
  • boukenze.b/jeu-de-la-vie-tp-3
  • b22015696/game-of-life-template
  • s23026062/sahin-game-of-life-template
  • m22023183/game-of-life-MALEK
  • z23012739/game-of-life-template
  • p23021107/poussardin-malo-game-of-life-template
  • o21225801/game-of-life-template
  • alaboure/game-fo-life-template
  • t22007439/game-of-life-toullec
  • b23021750/game-of-life
  • c22029830/game-of-life-template-rafi
  • b23025683/game-of-life-template-tp-6
  • gnaves/game-of-life-template
  • a22025223/game-of-life-template-cristel
  • f22024692/game-of-life-template-paolo-mathis-erwan
  • t21233923/game-fo-life-template
  • h21231335/game-fo-life-template
  • l22023519/game-of-life-template-salma
  • p23020787/game-of-life-template
  • b21232450/game-of-life-template
  • s22031458/game-of-life
  • n21223697/tp-4-ngom
  • a22027291/game-of-life-of-salim
  • k22029508/tp-4
  • s19033421/game-of-life-template
  • b21229750/jeu-de-la-vie-tp-3
  • saddem.r/game-of-life-template
  • l3_s3_infoamu/s3/programmation-2/game-fo-life-template
29 results
Select Git revision
Show changes
Commits on Source (24)
Showing
with 1059 additions and 240 deletions
image: gradle:jdk16
image: openjdk:17-alpine
variables:
GRADLE_OPTS: "-Dorg.gradle.daemon=false"
before_script:
- export GRADLE_USER_HOME=`pwd`/.gradle
......@@ -8,11 +11,30 @@ cache:
- .gradle/wrapper
- .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:
stage: test
script:
- gradle test
script: ./gradlew test
artifacts:
when: always
reports:
junit: build/test-results/test/**/TEST-*.xml
\ No newline at end of file
junit: build/test-results/test/**/TEST-*.xml
cache:
key: "$CI_COMMIT_REF_NAME"
policy: pull
paths:
- build
- .gradle
\ No newline at end of file
......@@ -2,17 +2,22 @@
## Description du projet
Le [jeu de la vie](https://fr.wikipedia.org/wiki/Jeu_de_la_vie) n’est pas vraiment un jeu, puisqu'il ne nécessite aucun joueur.
Le [jeu de la vie](https://fr.wikipedia.org/wiki/Jeu_de_la_vie) est une implémentation d'un
modèle de calcul : les automates cellulaires.
Le jeu se déroule sur une grille à deux dimensions dont les cases qu’on appelle des cellules peuvent prendre deux états distincts : vivantes ou mortes.
Le modèle se présente sous la forme d'une grille à deux dimensions dont les cases, qu’on
appelle des cellules, peuvent prendre deux états distincts : vivantes ou mortes.
À chaque étape, l’évolution d’une cellule est entièrement déterminée par l’état de ses huit voisines de la façon suivante :
À chaque étape, de calcul, l'état de chaque cellule est recalculé. Le nouvel état d'une cellule
est entièrement déterminée par l’état de ses huit voisines de la façon suivante :
- Une cellule morte possédant exactement trois voisines vivantes devient vivante (elle naît).
- Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle meurt.
- Une cellule morte possédant exactement trois voisines vivantes devient vivante.
- Une cellule vivante possédant deux ou trois voisines vivantes le reste, sinon elle devient morte.
Le but de ce TP est de compléter le code fourni par le dépôt afin d'obtenir un simulateur de jeu de la vie.
## Membres du projet
Le but de ce TP est de compléter le programme fourni par le dépôt afin d'obtenir un simulateur de
jeu de la vie.
## Membre du projet
- 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
plugins {
id 'application'
id "org.openjfx.javafxplugin" version "0.0.10"
id "org.openjfx.javafxplugin" version "0.0.14"
}
javafx {
version = "17"
version = "22"
modules = [ 'javafx.controls', 'javafx.fxml' ]
}
......@@ -13,9 +13,9 @@ repositories {
}
dependencies {
testImplementation('org.junit.jupiter:junit-jupiter-api:5.7.2',
'org.hamcrest:hamcrest-library:2.2', 'net.obvj:junit-utils:1.3.1')
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.2'
testImplementation('org.junit.jupiter:junit-jupiter-api:5.10.0',
'org.assertj:assertj-core:3.24.2')
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
}
test {
......@@ -23,5 +23,5 @@ test {
}
application {
mainClassName = "GameOfLifeApplication"
mainClassName = "SimulatorApplication"
}
\ No newline at end of file
distributionBase=GRADLE_USER_HOME
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
zipStorePath=wrapper/dists
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
##
## Gradle start up script for UN*X
......@@ -44,7 +28,7 @@ APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
DEFAULT_JVM_OPTS=""
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
......@@ -72,7 +56,7 @@ case "`uname`" in
Darwin* )
darwin=true
;;
MSYS* | MINGW* )
MINGW* )
msys=true
;;
NONSTOP* )
......@@ -82,7 +66,6 @@ esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
......@@ -126,11 +109,10 @@ if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
......@@ -156,19 +138,19 @@ if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
else
eval `echo args$i`="\"$arg\""
fi
i=`expr $i + 1`
i=$((i+1))
done
case $i in
0) set -- ;;
1) set -- "$args0" ;;
2) set -- "$args0" "$args1" ;;
3) set -- "$args0" "$args1" "$args2" ;;
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
......@@ -177,9 +159,14 @@ save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=`save "$@"`
APP_ARGS=$(save "$@")
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
cd "$(dirname "$0")"
fi
exec "$JAVACMD" "$@"
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto execute
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto execute
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
#!/bin/sh
#
# Copyright © 2015-2021 the original authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
#
# Gradle start up script for POSIX generated by Gradle.
#
# Important for running:
#
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
# noncompliant, but you have some other compliant shell such as ksh or
# bash, then to run this script, type that shell name before the whole
# command line, like:
#
# ksh Gradle
#
# Busybox and similar reduced shells will NOT work, because this script
# requires all of these POSIX shell features:
# * functions;
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
# * compound commands having a testable exit status, especially «case»;
# * various built-in commands including «command», «set», and «ulimit».
#
# Important for patching:
#
# (2) This script targets any POSIX shell, so it avoids extensions provided
# by Bash, Ksh, etc; in particular arrays are avoided.
#
# The "traditional" practice of packing multiple parameters into a
# space-separated string is a well documented source of bugs and security
# problems, so this is (mostly) avoided, by progressively accumulating
# options in "$@", and eventually passing that to Java.
#
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
# see the in-line comments for details.
#
# There are tweaks for specific operating systems such as AIX, CygWin,
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
#
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
app_path=$0
# Need this for daisy-chained symlinks.
while
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
[ -h "$app_path" ]
do
ls=$( ls -ld "$app_path" )
link=${ls#*' -> '}
case $link in #(
/*) app_path=$link ;; #(
*) app_path=$APP_HOME$link ;;
esac
done
# This is normally unused
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='-Dfile.encoding=UTF-8 "-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
warn () {
echo "$*"
} >&2
die () {
echo
echo "$*"
echo
exit 1
} >&2
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "$( uname )" in #(
CYGWIN* ) cygwin=true ;; #(
Darwin* ) darwin=true ;; #(
MSYS* | MINGW* ) msys=true ;; #(
NONSTOP* ) nonstop=true ;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD=$JAVA_HOME/jre/sh/java
else
JAVACMD=$JAVA_HOME/bin/java
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD=java
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
case $MAX_FD in #(
max*)
# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC3045
MAX_FD=$( ulimit -H -n ) ||
warn "Could not query maximum file descriptor limit"
esac
case $MAX_FD in #(
'' | soft) :;; #(
*)
# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
# shellcheck disable=SC3045
ulimit -n "$MAX_FD" ||
warn "Could not set maximum file descriptor limit to $MAX_FD"
esac
fi
# Collect all arguments for the java command, stacking in reverse order:
# * args from the command line
# * the main class name
# * -classpath
# * -D...appname settings
# * --module-path (only if needed)
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
JAVACMD=$( cygpath --unix "$JAVACMD" )
# Now convert the arguments - kludge to limit ourselves to /bin/sh
for arg do
if
case $arg in #(
-*) false ;; # don't mess with options #(
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
[ -e "$t" ] ;; #(
*) false ;;
esac
then
arg=$( cygpath --path --ignore --mixed "$arg" )
fi
# Roll the args list around exactly as many times as the number of
# args, so each arg winds up back in the position where it started, but
# possibly modified.
#
# NB: a `for` loop captures its iteration list before it begins, so
# changing the positional parameters here affects neither the number of
# iterations, nor the values presented in `arg`.
shift # remove old arg
set -- "$@" "$arg" # push replacement arg
done
fi
# Collect all arguments for the java command;
# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
# shell script including quotes and variable substitutions, so put them in
# double quotes to make sure that they get re-expanded; and
# * put everything else in single quotes, so that it's not re-expanded.
set -- \
"-Dorg.gradle.appname=$APP_BASE_NAME" \
-classpath "$CLASSPATH" \
org.gradle.wrapper.GradleWrapperMain \
"$@"
# Stop when "xargs" is not available.
if ! command -v xargs >/dev/null 2>&1
then
die "xargs is not available"
fi
# Use "xargs" to parse quoted args.
#
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
#
# In Bash we could simply go:
#
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
# set -- "${ARGS[@]}" "$@"
#
# but POSIX shell has neither arrays nor command substitution, so instead we
# post-process each arg (as a line of input to sed) to backslash-escape any
# character that might be a shell metacharacter, then use eval to reverse
# that process (while maintaining the separation between arguments), and wrap
# the whole thing up as a single "set" statement.
#
# This will of course break if any of these variables contains a newline or
# an unmatched quote.
#
eval "set -- $(
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
xargs -n1 |
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
tr '\n' ' '
)" '"$@"'
exec "$JAVACMD" "$@"
import controller.Controller;
import controller.Simulation;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import model.GameOfLife;
import model.Grid;
import model.CellularAutomatonSimulation;
import model.automata.GameOfLifeAutomaton;
import java.io.IOException;
import java.net.URL;
import static java.util.Objects.requireNonNull;
import java.util.Random;
/**
* Entry point for <i>The Game of Life</i> application.
*
*/
public class GameOfLifeApplication extends Application {
public class SimulatorApplication extends Application {
public static final int NUMBER_OF_ROWS = 40;
public static final int NUMBER_OF_COLUMNS = 70;
private static final int NUMBER_OF_ROWS = 40;
private static final int NUMBER_OF_COLUMNS = 70;
public static final Random GENERATOR = new Random();
private static final String APP_NAME = "Game of Life";
private static final String APP_NAME = "2D Cellular automata";
private static final String VIEW_RESOURCE_PATH = "/view/view.fxml";
private final GameOfLife gameOfLife;
private final Simulation simulation;
private Stage primaryStage;
private Parent view;
/**
* Creates a new {@code GameOfLifeApplication} instance.
*/
public GameOfLifeApplication() {
this(new GameOfLife(new Grid(NUMBER_OF_ROWS, NUMBER_OF_COLUMNS)));
public SimulatorApplication() {
this.simulation =
new CellularAutomatonSimulation<>(
new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),
GENERATOR
);
}
/**
* Creates a new {@code GameOfLifeApplication} instance given a {@link GameOfLife} instance.
*
* @param gameOfLife the {@link GameOfLife} instance
* @throws NullPointerException if {@code gameOfLife} is {@code null}
*/
private GameOfLifeApplication(GameOfLife gameOfLife) {
this.gameOfLife = requireNonNull(gameOfLife, "game of life is null");
}
@Override
public void start(Stage primaryStage) throws IOException {
......@@ -63,11 +60,11 @@ public class GameOfLifeApplication extends Application {
private void initializeView() throws IOException {
FXMLLoader loader = new FXMLLoader();
URL location = GameOfLifeApplication.class.getResource(VIEW_RESOURCE_PATH);
URL location = SimulatorApplication.class.getResource(VIEW_RESOURCE_PATH);
loader.setLocation(location);
view = loader.load();
Controller controller = loader.getController();
controller.setGameOfLife(gameOfLife);
controller.setSimulation(simulation);
}
......
package controller;
import matrix.Coordinate;
import javafx.animation.Animation;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.fxml.FXML;
import javafx.scene.control.Label;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.ToggleGroup;
import model.GameOfLife;
import model.Grid;
import javafx.util.Duration;
import view.MatrixPane;
import static java.util.Objects.requireNonNull;
......@@ -15,6 +20,7 @@ import static java.util.Objects.requireNonNull;
*/
public class Controller {
public static final int PERIOD_IN_MILLISECONDS = 100;
@FXML
private ToggleButton playToggleButton;
@FXML
......@@ -23,12 +29,18 @@ public class Controller {
private Label generationNumberLabel;
@FXML
private MatrixPane matrixPane;
private Timeline timeline;
private GameOfLife gameOfLife;
public Simulation getSimulation() {
return simulation;
}
private Simulation simulation;
@FXML
private void initialize() {
initializePlayAndPauseToggleButtons();
updateTimeline();
}
private void initializePlayAndPauseToggleButtons() {
......@@ -38,47 +50,77 @@ public class Controller {
}
/**
* Sets {@link GameOfLife} instance.
*
* @param gameOfLife {@link GameOfLife} instance
* @throws NullPointerException if {@code gameOfLife} is {@code null}
*/
public void setGameOfLife(GameOfLife gameOfLife) {
this.gameOfLife = requireNonNull(gameOfLife, "game of life is null");
public void setSimulation(Simulation simulation) {
this.simulation = requireNonNull(simulation, "game of life is null");
setGenerationNumberLabelTextProperty();
initializeMatrixPane();
}
private void setGenerationNumberLabelTextProperty() {
generationNumberLabel.textProperty().bind(gameOfLife.generationNumberProperty().asString());
updateGenerationNumber(0);
this.simulation.setGenerationNumberChangeListener(
(oldValue, newValue) -> updateGenerationNumber(newValue)
);
}
private void updateGenerationNumber(int newValue) {
generationNumberLabel.textProperty().set(String.valueOf(newValue));
}
private void initializeMatrixPane() {
Grid grid = gameOfLife.getGrid();
matrixPane.initialize(grid);
matrixPane.initialize(this);
}
@FXML
private void playToggleButtonAction() {
gameOfLife.play();
this.play();
}
@FXML
private void pauseToggleButtonAction() {
gameOfLife.pause();
this.pause();
}
@FXML
private void resetButtonAction() {
gameOfLife.reset();
this.pause();
simulation.reset();
pauseToggleButton.setSelected(true);
}
@FXML
private void clearButtonAction() {
gameOfLife.clear();
this.pause();
simulation.clear();
pauseToggleButton.setSelected(true);
}
public Iterable<Coordinate> coordinates() {
return simulation;
}
private void updateTimeline() {
Duration duration = new Duration(Controller.PERIOD_IN_MILLISECONDS);
EventHandler<ActionEvent> eventHandler =
event -> simulation.updateToNextGeneration();
KeyFrame keyFrame = new KeyFrame(duration, eventHandler);
timeline = new Timeline(keyFrame);
timeline.setCycleCount(Animation.INDEFINITE);
}
/**
* Plays the game.
*/
public void play() {
timeline.play();
}
/**
* Pauses the game.
*/
public void pause() {
timeline.pause();
}
}
package controller;
import matrix.Coordinate;
import javafx.scene.paint.Color;
import model.OnChangeListener;
/**
* Represents a simulation of a 2D cellular automaton, such as the Game of Life.
* Provides methods for updating the simulation, retrieving information, and managing listeners.
*/
public interface Simulation extends Iterable<Coordinate> {
/**
* Returns the number of columns in the simulation grid.
*
* @return The number of columns in the grid.
*/
int numberOfColumns();
/**
* Returns the number of rows in the simulation grid.
*
* @return The number of rows in the grid.
*/
int numberOfRows();
/**
* Updates the simulation to the next generation. This is done by computing, for each
* coordinate, a new state that depends on the states of its neighbours.
*/
void updateToNextGeneration();
/**
* Changes the state at a given {@link Coordinate}. This is used to edit the grid with the mouse. It
* is not part of the simulation of the cellular automaton.
*
* @param coordinate The {@link Coordinate} to advance to the next state.
*/
void next(Coordinate coordinate);
/**
* Copies the state from the source {@link Coordinate} to the destination {@link Coordinate}.
*
* @param source The source {@link Coordinate}.
* @param destination The destination {@link Coordinate}.
*/
void copy(Coordinate source, Coordinate destination);
/**
* Gets the {@link Color} associated with the state at the specified {@link Coordinate}.
*
* @param coordinate The {@link Coordinate} to retrieve the color for.
* @return The {@link Color} associated with the state at the specified {@link Coordinate}.
*/
Color getColor(Coordinate coordinate);
/**
* Sets a listener to be executed when the state at the specified {@link Coordinate} changes.
*
* @param coordinate The {@link Coordinate} to listen for changes.
* @param listener The listener to execute when the state changes.
*/
void setChangeListener(Coordinate coordinate, Runnable listener);
/**
* Sets a listener to be executed when the generation number changes.
*
* @param listener The listener to execute when the generation number changes.
*/
void setGenerationNumberChangeListener(OnChangeListener<Integer> listener);
/**
* Resets the simulation to random states.
*/
void reset();
/**
* Clears the simulation, setting all states to their default values.
*/
void clear();
}
package matrix;
public class ConstantMatrixInitializer<T> implements MatrixInitializer<T> {
// TODO: add instance variables
public ConstantMatrixInitializer(T constant) {
// TODO
}
@Override
public T initialValueAt(Coordinate coordinate) {
// TODO
return null;
}
}
package matrix;
import java.util.List;
/**
* Represents a 2D integer coordinate used to specify positions in a grid.
*/
public record Coordinate(int x, int y) {
/**
* Creates a new {@link Coordinate} instance with the given {@code x} and {@code y} values.
*
* @param x The x-coordinate value.
* @param y The y-coordinate value.
* @return A new {@link Coordinate} instance.
*/
public static Coordinate of(int x, int y) {
// TODO: compléter ce fabriquant
return null;
}
/**
* Computes and returns the {@link Coordinate} to the left of this one.
*
* @return The left adjacent {@link Coordinate}.
*/
public Coordinate left() {
// TODO: à compléter
return null;
}
/**
* Computes and returns the {@link Coordinate} to the right of this one.
*
* @return The right adjacent {@link Coordinate}.
*/
public Coordinate right() {
// TODO: à compléter
return null;
}
/**
* Computes and returns the {@link Coordinate} above this one.
*
* @return The above adjacent {@link Coordinate}.
*/
public Coordinate above() {
// TODO: à compléter
return null;
}
/**
* Computes and returns the {@link Coordinate} below this one.
*
* @return The below adjacent {@link Coordinate}.
*/
public Coordinate below() {
// TODO: à compléter
return null;
}
/**
* Computes and returns a list of orthogonal (adjacent in horizontal or vertical direction) neighbors.
* | | | |
* ---------
* | |X| |
* ---------
* |X|O|X|
* ---------
* | |X| |
* ---------
* | | | |
* @return A list of orthogonal neighboring {@link Coordinate}s.
*/
public List<Coordinate> orthogonalNeighbours() {
// TODO: à compléter
return List.of();
}
/**
* Computes and returns a list of diagonal (adjacent in diagonal direction) neighbors.
* | | | |
* ---------
* |X| |X|
* ---------
* | |O| |
* ---------
* |X| |X|
* ---------
* | | | |
*
* @return A list of diagonal neighboring {@link Coordinate}s.
*/
public List<Coordinate> diagonalNeighbours() {
// TODO: à compléter
return List.of();
}
/**
* Computes and returns a list of all orthogonal and diagonal neighbors.
* * | | | |
* * ---------
* * |X|X|X|
* * ---------
* * |X|O|X|
* * ---------
* * |X|X|X|
* * ---------
* * | | | |
*
* @return A list of all neighboring {@link Coordinate}s.
*/
public List<Coordinate> orthodiagonalNeighbours() {
// TODO: à compléter
return List.of();
}
@Override
public String toString() {
return "(" + this.x + "," + this.y + ")";
}
public Coordinate minus(Coordinate corner) {
return new Coordinate(this.x - corner.x, this.y - corner.y);
}
public Coordinate plus(Coordinate corner) {
return new Coordinate(this.x + corner.x, this.y + corner.y);
}
}
\ No newline at end of file
package matrix;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* An {@link Iterator} for generating 2D {@link Coordinate}s within a specified width and
* height range.
*/
class CoordinateIterator implements Iterator<Coordinate> {
/**
* Creates a new {@link CoordinateIterator} with the specified width and height.
*
* @param width The width of the coordinate range.
* @param height The height of the coordinate range.
*/
public CoordinateIterator(int width, int height) {
// TODO: à compléter
}
/**
* Checks if there are more {@link Coordinate}s to iterate over.
*
* @return true if there are more {@link Coordinate}s; otherwise, false.
*/
@Override
public boolean hasNext() {
// TODO: à compléter
return false;
}
/**
* Returns the next {@link Coordinate} in the iteration.
*
* @return The next {@link Coordinate} in the iteration.
* @throws NoSuchElementException if there are no more {@link Coordinate}s to iterate over.
*/
@Override
public Coordinate next() {
// TODO: à compléter
return null;
}
}
package matrix;
import java.util.List;
/**
* Represents a matrix, a rectangular array, with generic values in each cell.
*
* @param <T> The type of values stored in the matrix cells.
*/
public class ListMatrix<T> implements Matrix<T> {
private final List<List<T>> matrix;
private final int width;
private final int height;
/**
* Creates a new {@link ListMatrix} with the specified width, height, and an initializer to set
* values.
*
* @param width The width of the {@link ListMatrix}.
* @param height The height of the {@link ListMatrix}.
* @param initializer A matrix initializer to set values in the {@link ListMatrix}.
*/
public ListMatrix(int width, int height, MatrixInitializer<T> initializer) {
// TODO
this.width = 0;
this.height = 0;
this.matrix = null;
this.initializeWith(initializer); // fills the matrix using initializer
}
public ListMatrix(int width, int height, T constant) {
this(width, height, new ConstantMatrixInitializer<>(constant));
}
private void initializeWith(MatrixInitializer<T> initializer) {
// TODO initialize each cell of the matrix, with a value determined by initializer
}
public int width() {
// TODO
return 0;
}
public int height() {
// TODO
return 0;
}
@Override
public T get(int x, int y) {
// TODO
return null;
}
@Override
public void set(int x, int y, T newValue) {
// TODO
}
public Matrix<T> subMatrix(Coordinate corner, int width, int height) {
// TODO
return this;
}
}
package matrix;
import java.util.Iterator;
public interface Matrix<T> extends Iterable<T> {
/**
* Returns the width of the {@link Matrix}.
*
* @return The width of the {@link Matrix}.
*/
int width();
/**
* Returns the height of the {@link Matrix}.
*
* @return The height of the {@link Matrix}.
*/
int height();
/**
* Returns the value at the specified coordinates (x, y) in
* the {@link Matrix}.
*
* @param x The x-coordinate.
* @param y The y-coordinate.
* @return The content of the matrix at the coordinates (x,y).
*/
T get(int x, int y);
/**
* Returns the value at the specified coordinates (x, y) in
* the {@link Matrix}.
*
* @param coordinate The coordinates (x,y).
* @return The content of the matrix at the coordinates (x,y).
*/
default T get(Coordinate coordinate) {
return this.get(coordinate.x(), coordinate.y());
}
/**
* Changes the value at the specified coordinates (x,y) in the {@link Matrix}
*
* @param x the x-coordinate
* @param y the y-coordinate
* @param newValue the value to assign to coordinates (x,y).
*/
void set(int x, int y, T newValue);
/**
* Changes the value at the specified coordinates (x,y) in the {@link Matrix}
*
* @param coordinate The coordinates (x,y)
* @param newValue the value to assign to coordinates (x,y).
*/
default void set(Coordinate coordinate, T newValue) {
this.set(coordinate.x(), coordinate.y(), newValue);
}
Matrix<T> subMatrix(Coordinate corner, int width, int height);
/**
* Returns an {@link Iterable} that provides access to the {@link Coordinate}s of the
* {@link Matrix} in row-major order. This means that a {@code for} loop on a {@link Matrix}
* will loop over the coordinates of the {@link Matrix}.
*
* @return An {@link Iterable} for the {@link Coordinate}s of the {@link Matrix}.
*/
default Iterable<Coordinate> coordinates() {
return () -> new CoordinateIterator(this.width(), this.height());
}
/**
* Returns an {@link Iterator} that allows iterating over the elements in the {@link Matrix} in
* row-major order.
*
* @return An {@link Iterator} for the {@link Matrix}.
*/
default Iterator<T> iterator() {
Iterator<Coordinate> coords =
new CoordinateIterator(this.width(),this.height());
return new MatrixIterator<>(this, coords);
}
}
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);
}
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());
}
}
package model;
import javafx.beans.property.Property;
import javafx.beans.property.SimpleObjectProperty;
import java.util.ArrayList;
import java.util.List;
/**
* {@link Cell} instances represent the cells of <i>The Game of Life</i>.
* A class representing a cell that holds a value and allows adding listeners to track value changes.
*
* @param <T> The type of value stored in the cell.
*/
public class Cell<T> implements Lens<T> {
public class Cell {
private final Property<CellState> stateProperty = new SimpleObjectProperty<>(CellState.DEAD);
//TODO: ajouter la ou les propriétés nécessaires
/**
* Determines whether this {@link Cell} is alive or not.
*
* @return {@code true} if this {@link Cell} is alive and {@code false} otherwise
*/
// la liste des objets écoutant les modifications du contenu de la cellule
private final List<OnChangeListener<T>> listeners = new ArrayList<>();
public boolean isAlive() {
return getState().isAlive;
}
/**
* Sets the state of this {@link Cell}.
/** Initialize a new cell with a given value.
*
* @param cellState the new state of this {@link Cell}
* @param initialContent the value initially stored by the cell.
*/
public void setState(CellState cellState) {
getStateProperty().setValue(cellState);
public Cell(T initialContent) {
//TODO: à compléter
}
/**
* Returns the current state of this {@link Cell}.
/** Add a {@link OnChangeListener} to react to any change of value in the cell.
*
* @return the current state of this {@link Cell}
* @param listener the {@link OnChangeListener} to activate when the value in the cell is
* changed.
*/
public CellState getState(){
return getStateProperty().getValue();
public void addOnChangeListener(OnChangeListener<T> listener) {
this.listeners.add(listener);
}
/**
* Change the state of this {@link Cell} from ALIVE to DEAD or from DEAD to ALIVE.
* Sets the content of this {@link Cell}. This will also call all the listeners that were
* registered by the method {@code addOnChangeListener}.
*
* @param value the new content of this {@link Cell}
*/
public void toggleState() {
CellState[] possibleStates = CellState.values();
int stateOrdinal = getState().ordinal();
int numberOfPossibleStates = possibleStates.length;
setState(possibleStates[(stateOrdinal+1)%numberOfPossibleStates]);
public void set(T value) {
//TODO: modifier le contenu de la cellule, puis appeler les méthodes valueChanged des
// listeners
}
/**
* Returns this {@link Cell}'s state property.
* Returns the current content of this {@link Cell}.
*
* @return this {@link Cell}'s state property.
* @return the current content of this {@link Cell}
*/
public Property<CellState> getStateProperty() {
return stateProperty;
public T get(){
//TODO: à compléter
return null;
}
}
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;
}
}
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
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();
}
}