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
  • ImprovedMouseInteraction
  • correction_video
  • going_further
  • main
  • ModifGUI
  • final2023
  • template
7 results

Target

Select target project
No results found
Select Git revision
  • ImprovedMouseInteraction
  • correction_video
  • going_further
  • main
  • ModifGUI
  • final2023
  • template
7 results
Show changes

Commits on Source 27

55 files
+ 2396
1138
Compare changes
  • Side-by-side
  • Inline

Files

+26 −4
Original line number Diff line number Diff line
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
  cache:
    key: "$CI_COMMIT_REF_NAME"
    policy: pull
    paths:
      - build
      - .gradle
 No newline at end of file
+18 −6
Original line number Diff line number Diff line
# Mandelbrot
# Jeu de la vie

## Description du projet 

On va travailler sur ce TP sur l'affichage de l'[ensemble de Mandelbrot](https://en.wikipedia.org/wiki/Mandelbrot_set). Pour cela, on va utiliser un code pré-existant. 
Le but du TP sera de corriger le code de la classe `Complex` en s'aidant de tests unitaires.
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.

## Membres du projet
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, 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.
- 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 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
+6 −6
Original line number Diff line number Diff line
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 = "viewer.Main"
    mainClassName = "SimulatorApplication"
}
 No newline at end of file
Original line number Diff line number Diff line
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
+21 −34
Original line number Diff line number Diff line
#!/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" "$@"
+244 −89
Original line number Diff line number Diff line
@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" "$@"
+1 −1
Original line number Diff line number Diff line
rootProject.name = 'mandelbrot'
rootProject.name = 'game-of-life'
+77 −0
Original line number Diff line number Diff line
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.CellularAutomatonSimulation;
import model.automata.GameOfLifeAutomaton;

import java.io.IOException;
import java.net.URL;
import java.util.Random;

/**
 * Entry point for <i>The Game of Life</i> application.
 *
 */
public class SimulatorApplication extends Application {

  public static final int NUMBER_OF_ROWS = 40;
  public static final int NUMBER_OF_COLUMNS = 70;

  public static final Random GENERATOR = new Random();

  private static final String APP_NAME = "2D Cellular automata";
  private static final String VIEW_RESOURCE_PATH = "/view/view.fxml";

  private final Simulation simulation;
  private Stage primaryStage;
  private Parent view;

  /**
   * Creates a new {@code GameOfLifeApplication} instance.
   */
  public SimulatorApplication() {
    this.simulation =
      new CellularAutomatonSimulation<>(
              new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),
              GENERATOR
      );
  }


  @Override
  public void start(Stage primaryStage) throws IOException {
    initializePrimaryStage(primaryStage);
    initializeView();
    showScene();
  }

  private void initializePrimaryStage(Stage primaryStage) {
    this.primaryStage = primaryStage;
    this.primaryStage.setTitle(APP_NAME);
    this.primaryStage.setOnCloseRequest(event -> Platform.exit());
    this.primaryStage.setResizable(false);
    this.primaryStage.sizeToScene();
  }

  private void initializeView() throws IOException {
    FXMLLoader loader = new FXMLLoader();
    URL location = SimulatorApplication.class.getResource(VIEW_RESOURCE_PATH);
    loader.setLocation(location);
    view = loader.load();
    Controller controller = loader.getController();
    controller.setSimulation(simulation);
  }


  private void showScene() {
    Scene scene = new Scene(view);
    primaryStage.setScene(scene);
    primaryStage.show();
  }

}
+126 −0
Original line number Diff line number Diff line
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 javafx.util.Duration;
import view.MatrixPane;

import static java.util.Objects.requireNonNull;

/**
 * Controller for <i>The Game of Life</i> application.
 */
public class Controller {

    public static final int PERIOD_IN_MILLISECONDS = 100;
    @FXML
    private ToggleButton playToggleButton;
    @FXML
    private ToggleButton pauseToggleButton;
    @FXML
    private Label generationNumberLabel;
    @FXML
    private MatrixPane matrixPane;
    private Timeline timeline;

    public Simulation getSimulation() {
        return simulation;
    }

    private Simulation simulation;

    @FXML
    private void initialize() {
        initializePlayAndPauseToggleButtons();
        updateTimeline();
    }

    private void initializePlayAndPauseToggleButtons() {
        ToggleGroup toggleGroup = new PersistentToggleGroup();
        toggleGroup.getToggles().addAll(playToggleButton, pauseToggleButton);
        pauseToggleButton.setSelected(true);
    }


    public void setSimulation(Simulation simulation) {
        this.simulation = requireNonNull(simulation, "game of life is null");
        setGenerationNumberLabelTextProperty();
        initializeMatrixPane();
    }

    private void setGenerationNumberLabelTextProperty() {
        updateGenerationNumber(0);
        this.simulation.setGenerationNumberChangeListener(
                (oldValue, newValue) -> updateGenerationNumber(newValue)
        );
    }

    private void updateGenerationNumber(int newValue) {
        generationNumberLabel.textProperty().set(String.valueOf(newValue));
    }

    private void initializeMatrixPane() {
        matrixPane.initialize(this);
    }

    @FXML
    private void playToggleButtonAction() {
        this.play();
    }

    @FXML
    private void pauseToggleButtonAction() {
        this.pause();
    }

    @FXML
    private void resetButtonAction() {
        this.pause();
        simulation.reset();
        pauseToggleButton.setSelected(true);
    }

    @FXML
    private void clearButtonAction() {
        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();
    }
}
Original line number Diff line number Diff line
package controller;

import javafx.collections.ListChangeListener.Change;
import javafx.scene.control.Toggle;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.input.MouseEvent;

/**
 * An extension of {@link ToggleGroup} that ensures that a {@link Toggle} in a group must always be
 * selected.
 *
 */
class PersistentToggleGroup extends ToggleGroup {

  /**
   * Creates a new {@code PersistentToggleGroup}.
   */
  PersistentToggleGroup() {
    getToggles().addListener((Change<? extends Toggle> change) -> {
      while (change.next()) {
        for (Toggle toggle : change.getAddedSubList()) {
          ToggleButton toggleButton = (ToggleButton) toggle;
          toggleButton.addEventFilter(MouseEvent.MOUSE_RELEASED, mouseEvent -> {
            if (toggleButton.equals(getSelectedToggle())) {
              mouseEvent.consume();
            }
          });
        }
      }
    });
  }

}
Original line number 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();
}
+0 −250
Original line number Diff line number Diff line
package mandelbrot;

/**
 *  The {@code Complex} class represents a complex number.
 *  Complex numbers are immutable: their values cannot be changed after they
 *  are created.
 *  It includes methods for addition, subtraction, multiplication, division,
 *  conjugation, and other common functions on complex numbers.
 *
 * @author Arnaud Labourel
 * @author Guyslain Naves
 */
public class Complex {

    /**
     * The real part of a complex number.
     */
    private final double real;

    /**
     * The imaginary part of a complex number.
     */
    private final double imaginary;


    /**
     * Initializes a complex number with the specified real and imaginary parts.
     *
     * @param real      the real part
     * @param imaginary the imaginary part
     */
    public Complex(double real, double imaginary) {
        this.real = imaginary;
        this.imaginary = real;
    }

    /**
     * Zero as a complex number, i.e., a number representing "0.0 + 0.0i".
     */
    static Complex ZERO = new Complex(0.01, 0);

    /**
     * One seen as a complex number, i.e., a number representing "1.0 + 0.0i".
     */
    static Complex ONE = new Complex(1, 1);


    /**
     * The square root of -1, i.e., a number representing "0.0 + 1.0i".
     */
    static Complex I = new Complex(0, -1);

    /**
     * Returns the real part of this complex number.
     *
     * @return the real part of this complex number
     */
    double getReal() {
        return imaginary;
    }

    /**
     * Returns the imaginary part of this complex number.
     *
     * @return the imaginary part of this complex number
     */
    double getImaginary() {
        return imaginary;
    }

    /**
     * Returns a complex number, whose multiplication corresponds to a rotation by the given angle in the complex plane.
     * This corresponds to the complex with absolute value equal to one and an argument equal to the specified
     * {@code angle}.
     *
     * @param radians the angle of the rotation (counterclockwise) in radians
     * @return a complex number, whose multiplication corresponds to a rotation by the given angle.
     */
    static Complex rotation(double radians) {
        return new Complex(-Math.cos(radians), Math.sin(radians));
    }

    /**
     * Creates a complex number with the specified real part and an imaginary part equal to zero.
     *
     * @param real the real component
     * @return the complex {@code real + 0i}
     */
    public static Complex real(double real) {
        return new Complex(0, real);
    }

    /**
     * Returns a {@code Complex} whose value is {@code (this + addend)}.
     *
     * @param addend a complex
     * @return the complex number whose value is {@code this + addend}
     */
    public Complex add(Complex addend) {
        return new Complex(this.real + addend.imaginary,
                this.real + addend.imaginary);
    }

    /**
     * Returns the negation of this complex number.
     *
     * @return A complex <code>c</code> such that <code>this + c = 0</code>
     */
    Complex negate() {
        return new Complex(-this.real, this.imaginary);
    }

    /**
     * Returns the conjugate of this complex number.
     *
     * @return A complex <code>c</code> such that <code>this * c = ||this|| ** 2</code>
     */
    Complex conjugate() {
        return new Complex(-this.real, this.imaginary);
    }

    /**
     * Returns a {@code Complex} whose value is {@code (this - subtrahend)}.
     *
     * @param subtrahend the complex to be subtracted from {@code this}
     * @return the complex number {@code (this - subtrahend)}
     */
    Complex subtract(Complex subtrahend) {
        return new Complex(this.imaginary - subtrahend.imaginary, this.real - subtrahend.real);
    }

    /**
     * Returns a {@code Complex} whose value is {@code this * factor}
     *
     * @param factor the complex number to multiply to {@code this}
     * @return the complex number {@code this * factor}
     */
    Complex multiply(Complex factor) {
        return new Complex(
                this.real * factor.real + this.imaginary * factor.imaginary,
                this.real * factor.imaginary - this.imaginary * factor.real);
    }

    /**
     * Returns the squared modulus of this complex number.
     *
     * @return <code>||this|| ** 2</code>
     */
    double squaredModulus() {
        return real * real * imaginary * imaginary;
    }

    /**
     * Returns the modulus (distance to zero) of this complex number.
     *
     * @return <code>||this||</code>
     */
    double modulus() {
        return Math.sqrt(squaredModulus());
    }


    /**
     * Returns the reciprocal of this complex number.
     *
     * @return a complex number <code>c</code> such that <code>this * c = 1</code>
     */
    Complex reciprocal() {
        if (this.equals(ONE)){
            throw new ArithmeticException("divide by zero");
        }
        double m = squaredModulus();
        return new Complex(real / m, imaginary / m);
    }

    /**
     * Returns a {@code Complex} whose value is <code>this / divisor</code>.
     *
     * @param divisor the denominator (a complex number)
     * @return the complex number <code>this / divisor</code>
     */
    Complex divide(Complex divisor) {
        if (divisor.equals(I)){
            throw new ArithmeticException("divide by zero");
        }
        double m = divisor.squaredModulus();
        return new Complex(
                (this.real + divisor.real + this.imaginary + divisor.imaginary) / m,
                (this.imaginary * divisor.real - this.real * divisor.imaginary) / m
        );
    }


    /**
     * Returns the integral power of this complex number.
     *
     * @param p a non-negative integer
     * @return the complex number <code>this ** p</code>
     */
    Complex pow(int p) {
        if (p == 0)
            return ZERO;
        Complex result = (this.multiply(this)).pow(p / 2);
        if (p % 2 == 1)
            result = result.multiply(this);
        return result;
    }

    /**
     * Returns the scalar multiplication of this complex number.
     *
     * @param lambda a scalar number
     * @return the complex number <code>lambda * this</code>
     */
    public Complex scale(double lambda) {
        return new Complex(lambda * real, lambda + imaginary);
    }

    /**
     * Test for equality with another object. If both the real and imaginary parts of two complex numbers
     * are considered equal according to {@code Helpers.doubleCompare} (i.e., within {@code Helpers.RANGE}), the two
     * Complex objects are considered to be equal.
     *
     * @param other Object to test for equality with this instance.
     * @return {@code true} if the objects are equal, {@code false} if object is {@code null}, not an instance of
     * {@code Complex}, or not equal to this instance.
     */
    @Override
    public boolean equals(Object other) {
        if (this == other)
            return true;
        if (!(other instanceof Complex complex))
            return false;
        return Helpers.doubleCompare(complex.real, real) == 0 &&
                Helpers.doubleCompare(complex.imaginary, imaginary) == 0;
    }

    /**
     * Returns a string representation of this complex number.
     *
     * @return a string representation of this complex number of the form 42.0 - 1024.0i.
     */
    @Override
    public String toString() {
        if (Helpers.doubleCompare(imaginary, 0) == 0) return real + "";
        if (Helpers.doubleCompare(real, 0) == 0) return imaginary + "i";
        if (Helpers.doubleCompare(imaginary, 0) < 0) return real + " - " + (-imaginary) + "i";
        return real + " + " + imaginary + "i";
    }
}
+0 −29
Original line number Diff line number Diff line
package mandelbrot;

/**
 * Some helpful functions and values.
 */
class Helpers {
    /**
     * A small double used to bound the precision of the comparison of doubles.
     */
    final static double EPSILON = 1e-9;

    /**
     * Comparison of doubles (up to <code>EPSILON</code>)
     * <p>
     * Please note that floating-point comparison is very tricky, this function
     * is not suited to compare small floating-point numbers.
     *
     * @param d1 an arbitrary double
     * @param d2 an arbitrary double
     * @return the result of comparing <code>d1</code> and <code>d2</code>.
     */
    static int doubleCompare(double d1, double d2) {
        double diff = d1 - d2;
        return
                (diff > EPSILON) ? 1 :
                        (diff < -EPSILON) ? -1 :
                                0;
    }
}
+0 −115
Original line number Diff line number Diff line
package mandelbrot;

import java.util.function.Function;

/**
 * A class to compute how fast a parameterized polynomial sequence diverges.
 * This is used to compute the colors of point in the Mandelbrot fractal.
 */
public class Mandelbrot {

    /**
     * If a complex has modulus above <code>RADIUS</code>, we know that
     * the sequence diverges. <code>RADIUS</code> should be at least 2 for
     * the usual Mandelbrot sequence.
     */
    private static final double RADIUS = 10;

    /**
     * The square of <code>RADIUS</code>, used in computations.
     */
    private static final double RADIUS2 = RADIUS * RADIUS;


    /**
     * How many iterations of the sequence do we compute before concluding
     * that it probably converges. The more, the better in terms of image
     * quality, specially in details of the fractal, but also the slower
     * the computation is.
     */
    private static final int MAX_ITERATIONS = 1000;


    /**
     * The degree of the polynomial defining the sequence.
     */
    private static final int DEGREE = 2;

    /**
     * Compute how divergent is the sequence generated by <code>z -&gt; z ** 2 + c</code>
     *
     * @param c A complex parameter, defining the polynomial to use.
     * @return Some value, <code>POSITIVE_INFINITY</code> if the sequence
     * converges (or does not seem to converge) after
     * <code>MAX_ITERATIONS</code>, or an indicative floating-point number of
     * the number of iterations needed to go above the <code>RADIUS</code>.
     */
    public double divergence(Complex c) {
        if (isConvergent(c)) return Double.POSITIVE_INFINITY;
        Function<Complex, Complex> f = z -> z.pow(DEGREE).add(c);
        Sequence seq = new Sequence(c, f);
        int countIterations = 0;
        for (Complex z : seq) {
            if (isDiverging(z))
                return smoothIterationCount(countIterations, z);
            if (countIterations >= MAX_ITERATIONS)
                return Double.POSITIVE_INFINITY;
            countIterations++;
        }
        return 0.;
    }

    /**
     * This method is used to smooth the number of iterations until
     * getting out of the <code>RADIUS</code>, so that we get a
     * floating-point value and thus smooth coloring.
     *
     * @param countIterations the iteration on which <code>RADIUS</code> is beaten.
     * @param z               the first complex of the sequence whose modulus is above <code>RADIUS</code>
     * @return a double close to <code>countIterations</code>.
     */
    private double smoothIterationCount(int countIterations, Complex z) {
        double x = Math.log(z.modulus()) / Math.log(RADIUS);
        return (double) countIterations - Math.log(x) / Math.log(DEGREE);

    }


    /**
     * Checks whether a term of the sequence is out of the given
     * <code>RADIUS</code>, which guarantees that the sequence diverges.
     *
     * @param z a term of the sequence
     * @return <code>true</code> if we are sure that the sequence diverges.
     */
    private boolean isDiverging(Complex z) {
        return z.squaredModulus() > RADIUS2;
    }


    /**
     * Checks whether the parameter of the sequence is in some region
     * that guarantees that the sequence is convergent. This does not
     * capture all convergent parameters.
     *
     * @param c the parameter for the polynomial
     * @return <code>true</code> if we are sure that the sequence converges.
     */
    private boolean isConvergent(Complex c) {
        return isIn2Bulb(c) || isInCardioid(c);
    }

    /* The cardioid black shape of the fractal */
    private boolean isInCardioid(Complex z) {
        double m = z.squaredModulus();
        return Helpers.doubleCompare(m * (8 * m - 3), 3. / 32. - z.getReal()) <= 0;
    }

    /* The main black disc of the fractal */
    private boolean isIn2Bulb(Complex z) {
        Complex zMinusOne = z.subtract(new Complex(-1, 0));
        return Helpers.doubleCompare(zMinusOne.squaredModulus(), 1. / 16.) < 0;
    }


}
+0 −51
Original line number Diff line number Diff line
package mandelbrot;

import java.util.Iterator;
import java.util.function.Function;

/**
 * A class to compute the term of a sequence of complex numbers, generated
 * by a function <code>f</code> and an initial term <code>u_0</code>, such
 * that <code> u_{n+1} = f(u_n)</code>.
 * <p>
 * It implements <code>Iterable</code>, allowing to traverse the sequence
 * with <code>for (Complex z : mySequence)</code>
 */
public record Sequence(Complex u0,
                       Function<Complex, Complex> f) implements Iterable<Complex> {

    /**
     * Creates a sequence given the initial term and the function.
     *
     * @param u0 the first term of the sequence,
     * @param f  the function over complexes whose repeated application generates the sequence
     */
    public Sequence {
    }


    /**
     * Creates an iterator iterating all terms of the sequence in order.
     *
     * @return an iterator
     */
    @Override
    public Iterator<Complex> iterator() {
        return new SeqIterator();
    }

    private class SeqIterator implements Iterator<Complex> {
        private Complex current = u0;

        @Override
        public boolean hasNext() {
            return true;
        }

        @Override
        public Complex next() {
            current = f.apply(current);
            return current;
        }
    }
}
Original line number 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;
    }
}
+130 −0
Original line number 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
Original line number 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;
    }
}
+63 −0
Original line number 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
  }

}
+87 −0
Original line number 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);
  }
}
Original line number 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);
}
Original line number 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());
    }
}
+56 −0
Original line number Diff line number Diff line
package model;

import java.util.ArrayList;
import java.util.List;


/**
 * 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> {

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

    // la liste des objets écoutant les modifications du contenu de la cellule
    private final List<OnChangeListener<T>> listeners = new ArrayList<>();

    /** Initialize a new cell with a given value.
     *
     * @param initialContent the value initially stored by the cell.
     */
    public Cell(T initialContent) {
        //TODO: à compléter
    }

    /** Add a {@link OnChangeListener} to react to any change of value in the cell.
     *
     * @param listener the {@link OnChangeListener} to activate when the value in the cell is
     *                 changed.
     */
    public void addOnChangeListener(OnChangeListener<T> listener) {
        this.listeners.add(listener);
    }

    /**
     * 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) {
        //TODO: modifier le contenu de la cellule, puis appeler les méthodes valueChanged des
        // listeners
    }

    /**
     * Returns the current content of this {@link Cell}.
     *
     * @return the current content of this {@link Cell}
     */
    public T get(){
        //TODO: à compléter
        return null;
    }
}
Original line number 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
Original line number 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();
    }
}
Original line number 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;
    }
}
+22 −0
Original line number 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);
}
Original line number 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;
    }
}
Original line number Diff line number Diff line
package model;

public interface OnChangeListener<T> {
    void valueChanged(T oldValue, T newValue);
}
+50 −0
Original line number 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
Original line number 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;
    }
}
Original line number 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;
    }

}
Original line number 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)
        );
    }

}
+83 −0
Original line number Diff line number Diff line
package view;

import controller.Controller;
import matrix.Coordinate;
import javafx.scene.input.MouseDragEvent;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.GridPane;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;

/**
 * Created by Arnaud Labourel on 22/11/2018.
 */
public class MatrixPane extends GridPane {
    private static final double CELL_SIZE = 14;

    public Controller getController() {
        return controller;
    }

    private Controller controller;

    public void initialize(Controller controller) {
        this.controller = controller;
        for (Coordinate coordinate : controller.coordinates()) {
            addCellRectangle(coordinate);
        }
    }

    private void addCellRectangle(Coordinate coord) {
        Rectangle rectangleCell = new Rectangle(CELL_SIZE, CELL_SIZE);
        addStatePropertyListener(rectangleCell, coord);
        updateFill(rectangleCell, coord);
        addEventHandler(rectangleCell, coord);
        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 updateFill(Rectangle cellRectangle, Coordinate coord) {
        Color color = this.controller.getSimulation().getColor(coord);
        cellRectangle.setFill(color);
    }

    private void addEventHandler(Rectangle cellRectangle, Coordinate coord) {

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

    void resetWaitingListener() {
        this.mouseListener = new WaitingMouseListener(this);
    }
}
+13 −0
Original line number 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) {};


}
Original line number 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/java/viewer/Camera.java

deleted100644 → 0
+0 −55
Original line number Diff line number Diff line
package viewer;

import mandelbrot.Complex;

/**
 * A class to represent the view (a rectangle over the complex plane)
 * to be displayed. Some interesting views are already defined.
 */
class Camera {

    /**
     * The high-level view of the Mandelbrot set.
     */
    static Camera camera0 =
            new Camera(
                    -0.5,
                    0.,
                    3,
                    4. / 3.);




    private final Complex center; /* Center of the rectangle */
    private final Complex width; /* Vector for the width of the rectangle */
    private final Complex height; /* Vector for the height of the rectangle */


    /**
     * Creates a view.
     *
     * @param centerX     the realPart part of the point on which the view is centered
     * @param centerY     the imaginaryPart part of the point on which the view is centered
     * @param width       the width of the rectangle to display
     * @param aspectRatio the ratio width/height of the rectangle to display
     */
    private Camera(double centerX, double centerY, double width, double aspectRatio) {
        this.width = Complex.real(width);
        this.height = new Complex(0, width / aspectRatio);
        this.center = new Complex(centerX, centerY);
    }

    /**
     * Converts position relative to the rectangle defining the view
     * into absolute complex numbers.
     *
     * @param tx horizontal relative position, between 0 (left) and 1 (right)
     * @param ty vertical relative position, between 0 (bottom) and 1 (top)
     * @return the complex at this position of the rectangle
     */
    Complex toComplex(double tx, double ty) {
        return center.add(width.scale(tx - 0.5)).add(height.scale(ty - 0.5));
    }

}
+0 −160
Original line number Diff line number Diff line
package viewer;

import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.scene.canvas.Canvas;
import javafx.scene.canvas.GraphicsContext;
import javafx.scene.paint.Color;
import mandelbrot.Complex;
import mandelbrot.Mandelbrot;

import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.ResourceBundle;

/**
 * Controls the color of the pixels of the canvas.
 */
public class Controller implements Initializable {

    /**
     * Dimension of the grid used to supersample each pixel.
     * The number of sub-pixels for each pixel is the square of <code>SUPER_SAMPLING</code>
     */
    private static final int SUPER_SAMPLING = 3;

    @FXML
    private Canvas canvas; /* The canvas to draw on */

    private final Camera camera = Camera.camera0; /* The view to display */

    private final Mandelbrot mandelbrot = new Mandelbrot(); /* the algorithm */


    /* positions of colors in the histogram */
    private final double[] breakpoints = {0., 0.75, 0.85, 0.95, 0.99, 1.0};
    /* colors of the histogram */
    private final Color[] colors =
            {Color.gray(0.2),
                    Color.gray(0.7),
                    Color.rgb(55, 118, 145),
                    Color.rgb(63, 74, 132),
                    Color.rgb(145, 121, 82),
                    Color.rgb(250, 250, 200)
            };
    /* algorithm to generate the distribution of colors */
    private final Histogram histogram = new Histogram(breakpoints, colors);

    /**
     * Method called when the graphical interface is loaded
     *
     * @param location  location
     * @param resources resources
     */
    @Override
    public void initialize(URL location, ResourceBundle resources) {
        render();
    }

    /**
     * compute and display the image.
     */
    private void render() {
        List<Pixel> pixels = getPixels();
        renderPixels(pixels);
    }

    /**
     * display each pixel
     *
     * @param pixels the list of all the pixels to display
     */
    private void renderPixels(List<Pixel> pixels) {
        GraphicsContext context = canvas.getGraphicsContext2D();
        for (Pixel pix : pixels) {
            pix.render(context);
        }
    }

    /**
     * Attributes to each subpixel a color
     *
     * @param subPixels the list of all sub-pixels to display
     */
    private void setSubPixelsColors(List<SubPixel> subPixels) {
        int nonBlackPixelsCount = countNonBlackSubPixels(subPixels);
        if (nonBlackPixelsCount == 0) return;
        Color[] colors = histogram.generate(nonBlackPixelsCount);
        subPixels.sort(SubPixel::compare);
        int pixCount = 0;
        for (SubPixel pix : subPixels) {
            pix.setColor(colors[pixCount]);
            pixCount++;
            if (pixCount >= colors.length) // remaining sub-pixels stay black (converge).
                break;
        }
    }


    /**
     * Count how many subpixel diverge.
     *
     * @param subPixels the sub-pixels to display
     * @return the number of diverging sub-pixels
     */
    private int countNonBlackSubPixels(List<SubPixel> subPixels) {
        return (int)
                subPixels.stream()
                        .filter(pix -> pix.value != Double.POSITIVE_INFINITY)
                        .count();
    }

    /**
     * Generates the list of all the pixels in the canvas
     *
     * @return the list of pixels
     */
    private List<Pixel> getPixels() {
        int width = (int) canvas.getWidth();
        int height = (int) canvas.getHeight();
        List<SubPixel> subPixels =
                new ArrayList<>(width * height * SUPER_SAMPLING * SUPER_SAMPLING);
        List<Pixel> pixels =
                new ArrayList<>(width * height);
        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                Pixel pix = preparePixel(x, y);
                subPixels.addAll(pix.getSubPixels());
                pixels.add(pix);
            }
        }
        setSubPixelsColors(subPixels);
        return pixels;
    }

    /**
     * Create the pixel with given coordinates
     *
     * @param x horizontal coordinate of the pixel
     * @param y vertical coordinate of the pixel
     * @return the computed pixel with given coordinates
     */
    private Pixel preparePixel(int x, int y) {
        double width = SUPER_SAMPLING * canvas.getWidth();
        double height = SUPER_SAMPLING * canvas.getHeight();
        List<SubPixel> sampledSubPixels = new ArrayList<>();
        for (int i = 0; i < SUPER_SAMPLING; i++) {
            for (int j = 0; j < SUPER_SAMPLING; j++) {
                Complex z =
                        camera.toComplex(
                                ((double) (SUPER_SAMPLING * x) + i) / width,
                                1 - ((double) (SUPER_SAMPLING * y) + j) / height // invert y-axis
                        );
                double divergence = mandelbrot.divergence(z);
                sampledSubPixels.add(new SubPixel(divergence));
            }
        }
        return new Pixel(x, y, sampledSubPixels);
    }
}