b3b75a8a3e25879de2a5e368583fc286b6e6531a to main · YAGOUBI Rim / Game of life Template

build.gradle

+1
−1

Original line number
Original line
Diff line number
Diff line

@@ -4,7 +4,7 @@ plugins {

}

}

javafx {

javafx {

    version = "20"

    version = "22"

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

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

}

}

gradle/wrapper/gradle-wrapper.properties

+1
−1

Original line number
Original line
Diff line number
Diff line

distributionBase=GRADLE_USER_HOME

distributionBase=GRADLE_USER_HOME

distributionPath=wrapper/dists

distributionPath=wrapper/dists

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

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

zipStoreBase=GRADLE_USER_HOME

zipStoreBase=GRADLE_USER_HOME

zipStorePath=wrapper/dists

zipStorePath=wrapper/dists

src/main/java/SimulatorApplication.java

+1
−5

Original line number
Original line
Diff line number
Diff line

@@ -7,16 +7,12 @@ import javafx.scene.Parent;

import javafx.scene.Scene;

import javafx.scene.Scene;

import javafx.stage.Stage;

import javafx.stage.Stage;

import model.CellularAutomatonSimulation;

import model.CellularAutomatonSimulation;

import model.automata.BriansBrainAutomaton;

import model.automata.GameOfLifeAutomaton;

import model.automata.GameOfLifeAutomaton;

import model.automata.SeedsAutomaton;

import java.io.IOException;

import java.io.IOException;

import java.net.URL;

import java.net.URL;

import java.util.Random;

import java.util.Random;

import static java.util.Objects.requireNonNull;

/**

/**

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

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

 *

 *

@@ -41,7 +37,7 @@ public class SimulatorApplication extends Application {

  public SimulatorApplication() {

  public SimulatorApplication() {

    this.simulation =

    this.simulation =

      new CellularAutomatonSimulation<>(

      new CellularAutomatonSimulation<>(

              new SeedsAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),

              new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),

              GENERATOR

              GENERATOR

      );

      );

  }

  }

src/main/java/controller/Controller.java

+9
−10

Original line number
Original line
Diff line number
Diff line

package controller;

package controller;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.animation.Animation;

import javafx.animation.Animation;

import javafx.animation.KeyFrame;

import javafx.animation.KeyFrame;

import javafx.animation.Timeline;

import javafx.animation.Timeline;

@@ -11,7 +11,6 @@ import javafx.scene.control.Label;

import javafx.scene.control.ToggleButton;

import javafx.scene.control.ToggleButton;

import javafx.scene.control.ToggleGroup;

import javafx.scene.control.ToggleGroup;

import javafx.util.Duration;

import javafx.util.Duration;

import model.CellularAutomatonSimulation;

import view.MatrixPane;

import view.MatrixPane;

import static java.util.Objects.requireNonNull;

import static java.util.Objects.requireNonNull;

@@ -51,13 +50,6 @@ public class Controller {

    }

    }

    /**

     * Sets {@link CellularAutomatonSimulation} instance.

     *

     * @param simulation {@link CellularAutomatonSimulation} instance

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

     */

    public void setSimulation(Simulation simulation) {

    public void setSimulation(Simulation simulation) {

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

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

        setGenerationNumberLabelTextProperty();

        setGenerationNumberLabelTextProperty();

@@ -65,7 +57,14 @@ public class Controller {

    }

    }

    private void setGenerationNumberLabelTextProperty() {

    private void setGenerationNumberLabelTextProperty() {

        generationNumberLabel.textProperty().bind(simulation.generationNumberProperty().asString());

        updateGenerationNumber(0);

        this.simulation.setGenerationNumberChangeListener(

                (oldValue, newValue) -> updateGenerationNumber(newValue)

        );

    }

    private void updateGenerationNumber(int newValue) {

        generationNumberLabel.textProperty().set(String.valueOf(newValue));

    }

    }

    private void initializeMatrixPane() {

    private void initializeMatrixPane() {

src/main/java/controller/Simulation.java

+57
−3

Original line number
Original line
Diff line number
Diff line

package controller;

package controller;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.beans.property.ReadOnlyLongProperty;

import javafx.scene.paint.Color;

import javafx.scene.paint.Color;

import model.OnChangeListener;

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

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

    int numberOfColumns();

    /**

     * Returns the number of rows in the simulation grid.

     *

     * @return The number of rows in the grid.

     */

    int numberOfRows();

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

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

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

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

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

    void setChangeListener(Coordinate coordinate, Runnable listener);

    ReadOnlyLongProperty generationNumberProperty();

    /**

     * Sets a listener to be executed when the generation number changes.

     *

     * @param listener The listener to execute when the generation number changes.

     */

    void setGenerationNumberChangeListener(OnChangeListener<Integer> listener);

    /**

     * Resets the simulation to random states.

     */

    void reset();

    void reset();

    /**

     * Clears the simulation, setting all states to their default values.

     */

    void clear();

    void clear();

}

}

src/main/java/datastruct/Coordinate.javadeleted100644 → 0

+0
−51

Original line number
Original line
Diff line number
Diff line

package datastruct;

import java.util.ArrayList;

import java.util.List;

public record Coordinate(int x, int y) {

    public static Coordinate of(int x, int y) {

        return new Coordinate(x,y);

    }

    public Coordinate left() {

        return new Coordinate(x-1,y);

    }

    public Coordinate right() {

        return new Coordinate(x+1,y);

    }

    public Coordinate above() {

        return new Coordinate(x,y+1);

    }

    public Coordinate below() {

        return new Coordinate(x, y-1);

    }

    public List<Coordinate> orthogonalNeighbours() {

        return List.of(

                this.right(),

                this.left(),

                this.above(),

                this.below()

        );

    }

    public List<Coordinate> diagonalNeighbours() {

        return List.of(

                this.right().above(),

                this.left().above(),

                this.left().below(),

                this.right().below()

        );

    }

    public List<Coordinate> orthodiagonalNeighbours() {

        List<Coordinate> neighbours = new ArrayList<>(this.orthogonalNeighbours());

        neighbours.addAll(this.diagonalNeighbours());

        return neighbours;

    }

}

src/main/java/datastruct/CoordinateIterator.javadeleted100644 → 0

+0
−35

Original line number
Original line
Diff line number
Diff line

package datastruct;

import java.util.Iterator;

import java.util.NoSuchElementException;

class CoordinateIterator implements Iterator<Coordinate> {

    private final int width;

    private final int height;

    private int x = 0;

    private int y = 0;

    public CoordinateIterator(int width, int height) {

        this.width = width;

        this.height = height;

    }

    @Override

    public boolean hasNext() {

        return y < this.height;

    }

    @Override

    public Coordinate next() {

        if (!this.hasNext()) {

            throw new NoSuchElementException();

        }

        Coordinate coord = new Coordinate(this.x, this.y);

        this.x = this.x + 1;

        if (this.x == this.width) {

            this.x = 0;

            this.y = this.y + 1;

        }

        return coord;

    }

}

src/main/java/datastruct/Lens.javadeleted100644 → 0

+0
−7

Original line number
Original line
Diff line number
Diff line

package datastruct;

public interface Lens<S> {

    S get();

    void set(S value);

}

src/main/java/datastruct/Matrix.javadeleted100644 → 0

+0
−92

Original line number
Original line
Diff line number
Diff line

package datastruct;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

public class Matrix<T> implements Iterable<T> {

    private final List<List<T>> matrix;

    private final int width;

    private final int height;

    public Matrix(int width, int height, MatrixInitializer<T> initializer) {

        this.width = width;

        this.height = height;

        this.matrix = new ArrayList<>();

        this.initializeWith(initializer);

    }

    public Matrix(int width, int height, T initialValue) {

        this(width, height, new ConstantMatrixInitializer<>(initialValue));

    }

    private void initializeWith(MatrixInitializer<T> initializer) {

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

            List<T> row = new ArrayList<>();

            this.matrix.add(row);

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

                row.add(initializer.initialValueAt(Coordinate.of(x,y)));

            }

        }

    }

    public int width() {

        return width;

    }

    public int height() {

        return height;

    }

    public T get(int x, int y) {

        return this.matrix.get(x).get(y);

    }

    public T get(Coordinate coord) {

        return this.get(coord.x(), coord.y());

    }

    public void set(int x, int y, T value) {

        this.matrix.get(x).set(y,value);

    }

    public void set(Coordinate coord, T value) {

        this.set(coord.x(), coord.y(), value);

    }

    public Iterator<T> iterator() {

        Iterator<Coordinate> coordIterator = this.coordinatesIterator();

        return new MatrixIterator<>(this, coordIterator);

    }

    public Iterable<Coordinate> coordinates() {

        return this::coordinatesIterator;

    }

    private Iterator<Coordinate> coordinatesIterator() {

        return new CoordinateIterator(this.width, this.height);

    }

    public Lens<T> at(int x, int y) {

        return new Lens<T>() {

            @Override

            public T get() {

                return Matrix.this.get(x,y);

            }

            @Override

            public void set(T value) {

                Matrix.this.set(x,y,value);

            }

        };

    }

    public Lens<T> at(Coordinate coord) {

        return this.at(coord.x(), coord.y());

    }

}

src/main/java/datastruct/MatrixInitializer.javadeleted100644 → 0

+0
−6

Original line number
Original line
Diff line number
Diff line

package datastruct;

public interface MatrixInitializer<T> {

    T initialValueAt(Coordinate coordinate);

}

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

+16
−0

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

public class ConstantMatrixInitializer<T> implements MatrixInitializer<T> {

public class ConstantMatrixInitializer<T> implements MatrixInitializer<T> {

    private final T constant;

  // TODO: add instance variables

  public ConstantMatrixInitializer(T constant) {

  public ConstantMatrixInitializer(T constant) {

        this.constant = constant;

    // TODO

  }

  }

    @Override

    @Override

    public T initialValueAt(Coordinate coordinate) {

    public T initialValueAt(Coordinate coordinate) {

        return constant;

      // TODO

      return null;

    }

    }

}

}

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

+130
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import java.util.List;

/**

 * Represents a 2D integer coordinate used to specify positions in a grid.

 */

public record Coordinate(int x, int y) {

    /**

     * Creates a new {@link Coordinate} instance with the given {@code x} and {@code y} values.

     *

     * @param x The x-coordinate value.

     * @param y The y-coordinate value.

     * @return A new {@link Coordinate} instance.

     */

    public static Coordinate of(int x, int y) {

        // TODO: compléter ce fabriquant

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} to the left of this one.

     *

     * @return The left adjacent {@link Coordinate}.

     */

    public Coordinate left() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} to the right of this one.

     *

     * @return The right adjacent {@link Coordinate}.

     */

    public Coordinate right() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} above this one.

     *

     * @return The above adjacent {@link Coordinate}.

     */

    public Coordinate above() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns the {@link Coordinate} below this one.

     *

     * @return The below adjacent {@link Coordinate}.

     */

    public Coordinate below() {

        // TODO: à compléter

        return null;

    }

    /**

     * Computes and returns a list of orthogonal (adjacent in horizontal or vertical direction) neighbors.

     *  | | | |

     * ---------

     *  | |X| |

     * ---------

     *  |X|O|X|

     * ---------

     *  | |X| |

     * ---------

     * | | | |

     * @return A list of orthogonal neighboring {@link Coordinate}s.

     */

    public List<Coordinate> orthogonalNeighbours() {

        // TODO: à compléter

        return List.of();

    }

    /**

     * Computes and returns a list of diagonal (adjacent in diagonal direction) neighbors.

     *  | | | |

     * ---------

     *  |X| |X|

     * ---------

     *  | |O| |

     * ---------

     *  |X| |X|

     * ---------

     * | | | |

     *

     * @return A list of diagonal neighboring {@link Coordinate}s.

     */

    public List<Coordinate> diagonalNeighbours() {

        // TODO: à compléter

        return List.of();

    }

    /**

     * Computes and returns a list of all orthogonal and diagonal neighbors.

     *      *  | | | |

     *      * ---------

     *      *  |X|X|X|

     *      * ---------

     *      *  |X|O|X|

     *      * ---------

     *      *  |X|X|X|

     *      * ---------

     *      * | | | |

     *

     * @return A list of all neighboring {@link Coordinate}s.

     */

    public List<Coordinate> orthodiagonalNeighbours() {

        // TODO: à compléter

        return List.of();

    }

    @Override

    public String toString() {

        return "(" + this.x + "," + this.y + ")";

    }

  public Coordinate minus(Coordinate corner) {

    return new Coordinate(this.x - corner.x, this.y - corner.y);

  }

  public Coordinate plus(Coordinate corner) {

      return new Coordinate(this.x + corner.x, this.y + corner.y);

  }

}

 No newline at end of file

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

+44
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import java.util.Iterator;

import java.util.NoSuchElementException;

/**

 * An {@link Iterator} for generating 2D {@link Coordinate}s within a specified width and

 * height range.

 */

class CoordinateIterator implements Iterator<Coordinate> {

    /**

     * Creates a new {@link CoordinateIterator} with the specified width and height.

     *

     * @param width  The width of the coordinate range.

     * @param height The height of the coordinate range.

     */

    public CoordinateIterator(int width, int height) {

        // TODO: à compléter

    }

    /**

     * Checks if there are more {@link Coordinate}s to iterate over.

     *

     * @return true if there are more {@link Coordinate}s; otherwise, false.

     */

    @Override

    public boolean hasNext() {

        // TODO: à compléter

        return false;

    }

    /**

     * Returns the next {@link Coordinate} in the iteration.

     *

     * @return The next {@link Coordinate} in the iteration.

     * @throws NoSuchElementException if there are no more {@link Coordinate}s to iterate over.

     */

    @Override

    public Coordinate next() {

        // TODO: à compléter

        return null;

    }

}

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

+63
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import java.util.List;

/**

 * Represents a matrix, a rectangular array, with generic values in each cell.

 *

 * @param <T> The type of values stored in the matrix cells.

 */

public class ListMatrix<T> implements Matrix<T> {

  private final List<List<T>> matrix;

  private final int width;

  private final int height;

  /**

   * Creates a new {@link ListMatrix} with the specified width, height, and an initializer to set

   * values.

   *

   * @param width       The width of the {@link ListMatrix}.

   * @param height      The height of the {@link ListMatrix}.

   * @param initializer A matrix initializer to set values in the {@link ListMatrix}.

   */

  public ListMatrix(int width, int height, MatrixInitializer<T> initializer) {

    // TODO

    this.width = 0;

    this.height = 0;

    this.matrix = null;

    this.initializeWith(initializer); // fills the matrix using initializer

  }

  public ListMatrix(int width, int height, T constant) {

    this(width, height, new ConstantMatrixInitializer<>(constant));

  }

  private void initializeWith(MatrixInitializer<T> initializer) {

    // TODO initialize each cell of the matrix, with a value determined by initializer

  }

  public int width() {

    // TODO

    return 0;

  }

  public int height() {

    // TODO

    return 0;

  }

  @Override

  public T get(int x, int y) {

    // TODO

    return null;

  }

  @Override

  public void set(int x, int y, T newValue) {

    // TODO

  }

}

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

+87
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import java.util.Iterator;

public interface Matrix<T> extends Iterable<T> {

  /**

   * Returns the width of the {@link Matrix}.

   *

   * @return The width of the {@link Matrix}.

   */

  int width();

  /**

   * Returns the height of the {@link Matrix}.

   *

   * @return The height of the {@link Matrix}.

   */

  int height();

  /**

   * Returns the value at the specified coordinates (x, y) in

   * the {@link Matrix}.

   *

   * @param x The x-coordinate.

   * @param y The y-coordinate.

   * @return The content of the matrix at the coordinates (x,y).

   */

  T get(int x, int y);

  /**

   * Returns the value at the specified coordinates (x, y) in

   * the {@link Matrix}.

   *

   * @param coordinate The coordinates (x,y).

   * @return The content of the matrix at the coordinates (x,y).

   */

  default T get(Coordinate coordinate) {

    return this.get(coordinate.x(), coordinate.y());

  }

  /**

   *  Changes the value at the specified coordinates (x,y) in the {@link Matrix}

   *

   * @param x the x-coordinate

   * @param y the y-coordinate

   * @param newValue the value to assign to coordinates (x,y).

   */

  void set(int x, int y, T newValue);

  /**

   *  Changes the value at the specified coordinates (x,y) in the {@link Matrix}

   *

   * @param coordinate The coordinates (x,y)

   * @param newValue the value to assign to coordinates (x,y).

   */

  default void set(Coordinate coordinate, T newValue) {

    this.set(coordinate.x(), coordinate.y(), newValue);

  }

  default Matrix<T> subMatrix(Coordinate corner, int width, int height){

    return null ;

  }

  /**

   * Returns an {@link Iterable} that provides access to the {@link Coordinate}s of the

   * {@link Matrix} in row-major order. This means that a {@code for} loop on a {@link Matrix}

   * will loop over the coordinates of the {@link Matrix}.

   *

   * @return An {@link Iterable} for the {@link Coordinate}s of the {@link Matrix}.

   */

  default Iterable<Coordinate> coordinates() {

    return () -> new CoordinateIterator(this.width(), this.height());

  }

  /**

   * Returns an {@link Iterator} that allows iterating over the elements in the {@link Matrix} in

   * row-major order.

   *

   * @return An {@link Iterator} for the {@link Matrix}.

   */

  default Iterator<T> iterator() {

    Iterator<Coordinate> coords =

      new CoordinateIterator(this.width(),this.height());

    return new MatrixIterator<>(this, coords);

  }

}

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

+18
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

/**

 * An interface for initializing a {@link ListMatrix} by providing initial values for each cell.

 *

 * @param <T> The type of values to initialize the {@link ListMatrix} with.

 */

public interface MatrixInitializer<T> {

    /**

     * Returns the initial value to be set in a {@link ListMatrix} cell at the specified

     * {@link Coordinate}.

     *

     * @param coordinate The {@link Coordinate} at which to set the initial value.

     * @return The initial value for the specified cell.

     */

    T initialValueAt(Coordinate coordinate);

}

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

+1
−1

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

import java.util.Iterator;

import java.util.Iterator;

import java.util.NoSuchElementException;

import java.util.NoSuchElementException;

src/main/java/model/Cell.java

+20
−14

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import datastruct.Lens;

import java.util.ArrayList;

import java.util.ArrayList;

import java.util.List;

import java.util.List;

/**

/**

 * {@link Cell} instances represent the cells of the grid in a simulation of cellular automata.

 * 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<T> implements Lens<T> {

    private T content;

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

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

    /** Initialize a new cell with a given value.

    /** Initialize a new cell with a given value.

@@ -18,23 +21,27 @@ public class Cell<T> implements Lens<T> {

     * @param initialContent the value initially stored by the cell.

     * @param initialContent the value initially stored by the cell.

     */

     */

    public Cell(T initialContent) {

    public Cell(T initialContent) {

        this.content = 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) {

    public void addOnChangeListener(OnChangeListener<T> listener) {

        this.listeners.add(listener);

        this.listeners.add(listener);

    }

    }

    /**

    /**

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

     * Sets the content of this {@link Cell}. This will also call all the listeners that were

     * registered by the method {@code addOnChangeListener}.

     *

     *

     * @param value the new content of this {@link Cell}

     * @param value the new content of this {@link Cell}

     */

     */

    public void set(T value) {

    public void set(T value) {

        this.content = value;

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

        for (OnChangeListener<T> listener : this.listeners) {

        // listeners

            listener.valueChanged(this.content, value);

        }

    }

    }

    /**

    /**

@@ -43,8 +50,7 @@ public class Cell<T> implements Lens<T> {

     * @return the current content of this {@link Cell}

     * @return the current content of this {@link Cell}

     */

     */

    public T get(){

    public T get(){

        return this.content;

        //TODO: à compléter

        return null;

    }

    }

}

}

src/main/java/model/CellularAutomaton.java

+33
−1

Original line number
Original line
Diff line number
Diff line

@@ -2,9 +2,41 @@ package model;

import java.util.Random;

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

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

    int numberOfColumns();

    /**

     * Returns the number of rows in the grid of the cellular automaton.

     *

     * @return The number of rows in the grid.

     */

    int numberOfRows();

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

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

    S randomState(Random generator);

}

}

 No newline at end of file

src/main/java/model/CellularAutomatonSimulation.java

+41
−71

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import controller.Simulation;

import controller.Simulation;

import datastruct.Coordinate;

import matrix.Coordinate;

import datastruct.Matrix;

import matrix.ListMatrix;

import javafx.beans.property.ReadOnlyLongProperty;

import javafx.beans.property.ReadOnlyLongWrapper;

import javafx.scene.paint.Color;

import javafx.scene.paint.Color;

import java.util.Iterator;

import java.util.Iterator;

import java.util.Random;

import java.util.Random;

import java.util.function.Supplier;

/**

/**

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

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

public class CellularAutomatonSimulation<S extends State<S>>

        implements Simulation {

        implements Simulation {

    private final Matrix<Cell<S>> grid;

    private final ListMatrix<Cell<S>> grid;

    private final ReadOnlyLongWrapper generationNumber = new ReadOnlyLongWrapper();

    private final Cell<Integer> generationNumber = new Cell<>(0);

    private final CellularAutomaton<S> automaton;

    private final CellularAutomaton<S> automaton;

    private final Random generator;

    private final Random generator;

    /**

    /**

     * Creates a new {@link CellularAutomatonSimulation} instance for a given automaton.

     * Creates a new {@link CellularAutomatonSimulation} instance for a given automaton.

     *

     *

     * @param automaton         a description of the {@link CellularAutomaton}

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

    public CellularAutomatonSimulation(CellularAutomaton<S> automaton, Random generator) {

        this.automaton = automaton;

        this.automaton = automaton;

        this.grid = new Matrix<>(

        this.grid = new ListMatrix<>(

                automaton.numberOfColumns(),

                automaton.numberOfColumns(),

                automaton.numberOfRows(),

                automaton.numberOfRows(),

                new ConstantCellInitializer<>(automaton.defaultState())

                new ConstantCellInitializer<>(automaton.defaultState())

@@ -38,68 +39,58 @@ public class CellularAutomatonSimulation<S extends State<S>>

        this.generator = generator;

        this.generator = generator;

    }

    }

    /**

     * Goes through each {@link Cell} in this {@code CellGrid} and sets it states with a

     * state obtained from the supplier.

     *

     * @param generator {@link Random} instance used to generate a random state for each cell

     *                  {@link Cell}.

     */

    public void fillRandomly(Random generator) {

        for (Cell<S> cell : this.grid) {

            cell.set(this.automaton.randomState(generator));

        }

    }

    @Override

    @Override

    public int numberOfColumns() {

    public int numberOfColumns() {

        return this.grid.width();

        //TODO: à compléter

        return 0;

    }

    }

    @Override

    @Override

    public int numberOfRows() {

    public int numberOfRows() {

        return this.grid.height();

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

    public Cell<S> at(Coordinate coordinate) {

        return this.grid.get(coordinate);

        //TODO: à compléter

        return null;

    }

    }

    @Override

    public void updateToNextGeneration() {

    public void updateToNextGeneration() {

        this.generationNumber.set(getGenerationNumber() + 1);

        //TODO: à compléter, en utilisant nextGenerationMatrix()

        Matrix<S> nextStates = this.nextGenerationMatrix();

        for (Coordinate coordinate : this.grid.coordinates()) {

            this.at(coordinate).set(nextStates.get(coordinate));

        }

    }

    }

    /** Computes the {link Matrix} of states obtained after a single step of updates

    /** Computes the {@link ListMatrix} of states obtained after a single step of updates

     * of the simulation.

     * of the simulation.

     *

     *

     * @return the states of each cell after one generation

     * @return the states of each cell after one generation

     */

     */

    private Matrix<S> nextGenerationMatrix() {

    private ListMatrix<S> nextGenerationMatrix() {

        return new Matrix<S>(

        //TODO: à compléter

                this.grid.width(),

        return null;

                this.grid.height(),

                new NextGenerationInitializer<>(this)

        );

    }

    }

    @Override

    @Override

    public void next(Coordinate coordinate) {

    public void next(Coordinate coordinate) {

        S oldState = this.grid.get(coordinate).get();

        //TODO: à compléter

        this.at(coordinate).set(oldState.next());

    }

    }

    @Override

    @Override

    public void copy(Coordinate source, Coordinate destination) {

    public void copy(Coordinate source, Coordinate destination) {

        System.out.println("bip (" + source + ") (" + destination + ")");

        //TODO: à compléter

        S state = this.at(source).get();

        this.at(destination).set(state);

    }

    }

    @Override

    @Override

    public Color getColor(Coordinate coordinate) {

    public Color getColor(Coordinate coordinate) {

        return this.at(coordinate).get().getColor();

        //TODO: à compléter

        return null;

    }

    }

    @Override

    @Override

@@ -109,42 +100,21 @@ public class CellularAutomatonSimulation<S extends State<S>>

        );

        );

    }

    }

    @Override

    /**

    public void setGenerationNumberChangeListener(OnChangeListener<Integer> listener){

     * Returns the current generationNumber.

        this.generationNumber.addOnChangeListener(listener);

     *

     * @return the current generationNumber

     */

    private long getGenerationNumber() {

        return this.generationNumber.get();

    }

    /**

     * Returns the generationNumber {@link ReadOnlyLongProperty}.

     *

     * @return the generationNumber {@link ReadOnlyLongProperty}

     */

    public ReadOnlyLongProperty generationNumberProperty() {

        return this.generationNumber.getReadOnlyProperty();

    }

    }

    /**

    @Override

     * Clears the current game.

     */

    public void clear() {

    public void clear() {

        for (Cell<S> cell : this.grid) {

        //TODO: à compléter (penser à remettre le nombre de génération à 0)

            cell.set(this.automaton.defaultState());

        }

        this.generationNumber.set(0);

    }

    }

    /**

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

    @Override

     */

    public void reset() {

    public void reset() {

        this.clear();

        //TODO: à compléter (penser à remettre le nombre de génération à 0)

        this.fillRandomly(this.generator);

    }

    }

    @Override

    @Override

src/main/java/model/ConstantCellInitializer.java

+18
−5

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import datastruct.Coordinate;

import matrix.Coordinate;

import datastruct.MatrixInitializer;

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

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

    private final T defaultValue;

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

    public ConstantCellInitializer(T defaultValue) {

        this.defaultValue = defaultValue;

        //TODO: à compléter

    }

    }

    @Override

    @Override

    public Cell<T> initialValueAt(Coordinate coordinate) {

    public Cell<T> initialValueAt(Coordinate coordinate) {

        return new Cell<>(defaultValue);

        //TODO: à compléter

        return null;

    }

    }

}

}

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

+22
−0

Original line number
Original line
Diff line number
Diff line

package model;

/**

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

 *

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

 */

public interface Lens<S> {

    /**

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

     *

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

     */

    S get();

    /**

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

     *

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

     */

    void set(S value);

}

src/main/java/model/NextGenerationInitializer.java

+34
−22

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import datastruct.Coordinate;

import matrix.Coordinate;

import datastruct.Matrix;

import matrix.MatrixInitializer;

import datastruct.MatrixInitializer;

import matrix.ListMatrix;

import controller.Simulation;

import java.util.ArrayList;

import java.util.List;

/**

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

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

    private final CellularAutomatonSimulation<S> simulation;

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

    public NextGenerationInitializer(CellularAutomatonSimulation<S> simulation) {

        this.simulation = simulation;

        //TODO: à compléter

    }

    }

    @Override

    @Override

    public S initialValueAt(Coordinate coordinate) {

    public S initialValueAt(Coordinate coordinate) {

        List<State<S>> neighbours = new ArrayList<>();

        //TODO: à compléter

        for (Coordinate neighbourCoord : coordinate.orthodiagonalNeighbours()) {

        return null;

            Coordinate wrapped = wrap(neighbourCoord);

            neighbours.add(this.simulation.at(wrapped).get());

        }

        S state = this.simulation.at(coordinate).get();

        return state.update(neighbours);

    }

    }

    private Coordinate wrap(Coordinate coordinate) {

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

        return new Coordinate(

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

                modulo(coordinate.x(),this.simulation.numberOfColumns()),

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

                modulo(coordinate.y(),this.simulation.numberOfRows())

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

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

@@ -39,7 +51,7 @@ public class NextGenerationInitializer<S extends State<S>> implements MatrixInit

     * @param d a non-zero integer.

     * @param d a non-zero integer.

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

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

     */

     */

    private static int modulo(int n, int d) {

    static int modulo(int n, int d) {

        int result = n % d;

        int result = n % d;

        return n < 0 ? result + d : result;

        return n < 0 ? result + d : result;

    }

    }

src/main/java/model/State.java

+37
−2

Original line number
Original line
Diff line number
Diff line

@@ -4,12 +4,47 @@ import javafx.scene.paint.Color;

import java.util.List;

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

public interface State<S> {

    /**

     * Returns the color associated with this state.

     *

     * @return The color representing this state.

     */

    Color getColor();

    Color getColor();

    /**

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

     *

     * @return The next state.

     */

    S next();

    S next();

    S update(List<State<S>> neighbours);

    /**

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

     *

     * @param neighbours A list of neighboring cell states.

     * @return The updated state based on the neighbors.

     */

    S update(List<S> neighbours);

    /**

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

     *

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

     * @param state     The state to count occurrences of.

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

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

     */

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

        //TODO: à compléter

        return 0;

    }

}

}

 No newline at end of file

src/main/java/model/automata/AbstractAutomaton.javadeleted100644 → 0

+0
−24

Original line number
Original line
Diff line number
Diff line

package model.automata;

import model.CellularAutomaton;

import model.State;

public abstract class AbstractAutomaton<S extends State<S>> implements CellularAutomaton<S> {

    private final int numberOfColumns;

    private final int numberOfRows;

    protected AbstractAutomaton(int numberOfColumns, int numberOfRows) {

        this.numberOfColumns = numberOfColumns;

        this.numberOfRows = numberOfRows;

    }

    public int numberOfColumns() {

        return numberOfColumns;

    }

    public int numberOfRows() {

        return numberOfRows;

    }

}

src/main/java/model/automata/BiColorAutomaton.javadeleted100644 → 0

+0
−25

Original line number
Original line
Diff line number
Diff line

package model.automata;

import model.CellularAutomaton;

import java.util.Random;

public class BiColorAutomaton extends AbstractAutomaton<BiColorState> {

    public BiColorAutomaton(int numberOfColumns, int numberOfRows) {

        super(numberOfColumns, numberOfRows);

    }

    @Override

    public BiColorState defaultState() {

        return BiColorState.DEAD;

    }

    @Override

    public BiColorState randomState(Random generator) {

        return generator.nextBoolean()? BiColorState.DEAD:

                generator.nextBoolean()? BiColorState.RED:

                        BiColorState.BLUE;

    }

}

src/main/java/model/automata/BiColorState.javadeleted100644 → 0

+0
−53

Original line number
Original line
Diff line number
Diff line

package model.automata;

import javafx.scene.paint.Color;

import model.State;

import java.util.List;

import java.util.Random;

public enum BiColorState implements State<BiColorState> {

    BLUE, RED, DEAD;

    @Override

    public Color getColor() {

        return switch (this) {

            case BLUE -> Color.BLUE;

            case RED -> Color.RED;

            case DEAD -> Color.WHITE;

        };

    }

    @Override

    public BiColorState next() {

        return switch (this) {

            case BLUE -> RED;

            case RED -> DEAD;

            case DEAD -> BLUE;

        };

    }

    @Override

    public BiColorState update(List<State<BiColorState>> neighbours) {

        int countBlue = 0;

        int countRed = 0;

        for (State<BiColorState> neighbour : neighbours) {

            if (neighbour == RED) {

                countRed++;

            }

            if (neighbour == BLUE) {

                countBlue++;

            }

        }

        if (this == DEAD) {

            return (countBlue + countRed != 3)? DEAD:

                    countBlue > countRed? BLUE:

                            RED;

        }

        return 2 <= countBlue + countRed && countBlue + countRed <= 3? this:

                DEAD;

    }

}

src/main/java/model/automata/BriansBrainAutomaton.javadeleted100644 → 0

+0
−22

Original line number
Original line
Diff line number
Diff line

package model.automata;

import java.util.Random;

public class BriansBrainAutomaton extends AbstractAutomaton<BriansBrainState> {

    public BriansBrainAutomaton(int numberOfColumns, int numberOfRows) {

        super(numberOfColumns, numberOfRows);

    }

    @Override

    public BriansBrainState defaultState() {

        return BriansBrainState.OFF;

    }

    @Override

    public BriansBrainState randomState(Random generator) {

        return generator.nextInt(10) == 0 ?

                 BriansBrainState.ON:

                 BriansBrainState.OFF;

    }

}

src/main/java/model/automata/BriansBrainState.javadeleted100644 → 0

+0
−51

Original line number
Original line
Diff line number
Diff line

package model.automata;

import javafx.scene.paint.Color;

import model.State;

import java.util.List;

import java.util.Random;

public enum BriansBrainState implements State<BriansBrainState> {

    ON, OFF, DYING;

    @Override

    public Color getColor() {

        return switch (this) {

            case ON -> Color.WHITE;

            case OFF -> Color.BLACK;

            case DYING -> Color.BLUE;

        };

    }

    @Override

    public BriansBrainState next() {

        return switch (this) {

            case ON -> DYING;

            case OFF -> ON;

            case DYING -> OFF;

        };

    }

    @Override

    public BriansBrainState update(List<State<BriansBrainState>> neighbours) {

        return switch (this) {

            case ON -> DYING;

            case DYING -> OFF;

            case OFF -> {

                int count = countList(ON, neighbours);

                yield count==2 ? ON : OFF;

            }

        };

    }

    static <T>  int countList(T value, List<T> elements) {

        int count = 0;

        for (T v : elements) {

            if (v.equals(value)) {

                count++;

            }

        }

        return count;

    }

}

src/main/java/model/automata/GameOfLifeAutomaton.java

+19
−7

Original line number
Original line
Diff line number
Diff line

@@ -4,21 +4,33 @@ import model.CellularAutomaton;

import java.util.Random;

import java.util.Random;

public class GameOfLifeAutomaton extends AbstractAutomaton<GameOfLifeState> {

public class GameOfLifeAutomaton implements CellularAutomaton<GameOfLifeState> {

    protected GameOfLifeAutomaton(int numberOfColumns, int numberOfRows) {

    public GameOfLifeAutomaton(int numberOfColumns, int numberOfRows) {

        super(numberOfColumns, numberOfRows);

        //TODO: à compléter

    }

    @Override

    public int numberOfColumns() {

        //TODO: à compléter

        return 0;

    }

    @Override

    public int numberOfRows() {

        //TODO: à compléter

        return 0;

    }

    }

    @Override

    @Override

    public GameOfLifeState defaultState() {

    public GameOfLifeState defaultState() {

        return GameOfLifeState.DEAD;

        //TODO: à compléter

        return null;

    }

    }

    @Override

    @Override

    public GameOfLifeState randomState(Random generator) {

    public GameOfLifeState randomState(Random generator) {

        return generator.nextBoolean()?

        //TODO: à compléter

                 GameOfLifeState.ALIVE:

        return null;

                 GameOfLifeState.DEAD;

    }

    }

}

}

src/main/java/model/automata/GameOfLifeState.java

+8
−21

Original line number
Original line
Diff line number
Diff line

@@ -4,43 +4,30 @@ import javafx.scene.paint.Color;

import model.State;

import model.State;

import java.util.List;

import java.util.List;

import java.util.Random;

/**

/**

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

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

 */

 */

public enum GameOfLifeState implements State<GameOfLifeState> {

public enum GameOfLifeState implements State<GameOfLifeState> {

    ALIVE(Color.RED),

    ALIVE, DEAD;

    DEAD(Color.WHITE);

    public final Color color;

    GameOfLifeState(Color color) {

        this.color = color;

    }

    @Override

    @Override

    public Color getColor() {

    public Color getColor() {

        return this.color;

        //TODO: à compléter

        return Color.BLACK;

    }

    }

    @Override

    @Override

    public GameOfLifeState next() {

    public GameOfLifeState next() {

        return GameOfLifeState.values()[1 - this.ordinal()];

        //TODO: à compléter

        return null;

    }

    }

    @Override

    @Override

    public GameOfLifeState update(List<State<GameOfLifeState>> neighbours) {

    public GameOfLifeState update(List<GameOfLifeState> neighbours) {

        int countAlive = 0;

        //TODO: à compléter

        for (State<GameOfLifeState> state : neighbours) {

        return null;

            if (state.equals(ALIVE)) {

                countAlive++;

            }

        }

        boolean isAlive =

                (this == DEAD && 3 == countAlive)

                || (this == ALIVE && 2 <= countAlive && countAlive <= 3);

        return isAlive ? ALIVE : DEAD;

    }

    }

}

}

src/main/java/model/automata/SeedsAutomaton.javadeleted100644 → 0

+0
−21

Original line number
Original line
Diff line number
Diff line

package model.automata;

import java.util.Random;

public class SeedsAutomaton extends AbstractAutomaton<SeedsState> {

    public SeedsAutomaton(int numberOfColumns, int numberOfRows) {

        super(numberOfColumns, numberOfRows);

    }

    @Override

    public SeedsState defaultState() {

        return SeedsState.OFF;

    }

    @Override

    public SeedsState randomState(Random generator) {

        return generator.nextInt() == 0?

                SeedsState.ON:

                SeedsState.OFF;

    }

}

src/main/java/model/automata/SeedsState.javadeleted100644 → 0

+0
−36

Original line number
Original line
Diff line number
Diff line

package model.automata;

import javafx.scene.paint.Color;

import model.State;

import java.util.List;

import static model.automata.BriansBrainState.countList;

public enum SeedsState implements State<SeedsState> {

    ON, OFF;

    @Override

    public Color getColor() {

        return switch (this) {

            case ON -> Color.WHITE;

            case OFF -> Color.BLACK;

        };

    }

    @Override

    public SeedsState next() {

        return switch (this) {

            case ON -> OFF;

            case OFF -> ON;

        };

    }

    @Override

    public SeedsState update(List<State<SeedsState>> neighbours) {

        return switch (this) {

            case ON -> OFF;

            case OFF -> countList(ON,neighbours) == 2 ? ON: OFF;

        };

    }

}

src/main/java/view/FillingMouseListener.java

+3
−2

Original line number
Original line
Diff line number
Diff line

package view;

package view;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.scene.input.MouseEvent;

import javafx.scene.input.MouseEvent;

public class FillingMouseListener implements MouseListener {

public class FillingMouseListener implements MouseListener {

@@ -14,7 +14,7 @@ public class FillingMouseListener implements MouseListener {

    }

    }

    @Override

    @Override

    public void onMouseReleased(MouseEvent event, Coordinate coord) {

    public void onMouseReleased(MouseEvent event, Coordinate coordinate) {

        this.matrix.resetWaitingListener();

        this.matrix.resetWaitingListener();

    }

    }

@@ -34,4 +34,5 @@ public class FillingMouseListener implements MouseListener {

                new FillingMouseListener(this.matrix, coordinate)

                new FillingMouseListener(this.matrix, coordinate)

        );

        );

    }

    }

}

}

src/main/java/view/MatrixPane.java

+2
−1

Original line number
Original line
Diff line number
Diff line

package view;

package view;

import controller.Controller;

import controller.Controller;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.scene.input.MouseDragEvent;

import javafx.scene.input.MouseDragEvent;

import javafx.scene.input.MouseEvent;

import javafx.scene.input.MouseEvent;

import javafx.scene.layout.GridPane;

import javafx.scene.layout.GridPane;

@@ -52,6 +52,7 @@ public class MatrixPane extends GridPane {

    }

    }

    private void addEventHandler(Rectangle cellRectangle, Coordinate coord) {

    private void addEventHandler(Rectangle cellRectangle, Coordinate coord) {

        cellRectangle.addEventHandler(

        cellRectangle.addEventHandler(

                MouseEvent.MOUSE_PRESSED,

                MouseEvent.MOUSE_PRESSED,

                event -> mouseListener.onMousePressed(event, coord)

                event -> mouseListener.onMousePressed(event, coord)

src/main/java/view/MouseListener.java

+2
−1

Original line number
Original line
Diff line number
Diff line

package view;

package view;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.scene.input.MouseEvent;

import javafx.scene.input.MouseEvent;

interface MouseListener {

interface MouseListener {

@@ -9,4 +9,5 @@ interface MouseListener {

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

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

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

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

}

}

src/main/java/view/WaitingMouseListener.java

+6
−4

Original line number
Original line
Diff line number
Diff line

package view;

package view;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.scene.input.MouseEvent;

import javafx.scene.input.MouseEvent;

class WaitingMouseListener implements MouseListener {

class WaitingMouseListener implements MouseListener {

@@ -13,8 +13,10 @@ class WaitingMouseListener implements MouseListener {

    }

    }

    @Override

    @Override

    public void onMousePressed(MouseEvent event, Coordinate coord) {

    public void onMousePressed(MouseEvent event, Coordinate coordinate) {

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

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

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

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

    }

    }

}

}

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

+31
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

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

class ConstantMatrixInitializerTest {

    @Test

    public void testMatrixInitializationWithConstantValue() {

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

        // Test that all cells have the constant value.

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

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

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

            }

        }

    }

    @Test

    public void testMatrixInitializationWithConstantValue2() {

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

        // Test that all cells have the constant value.

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

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

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

            }

        }

    }

}

 No newline at end of file

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

+53
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import java.util.NoSuchElementException;

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

class CoordinateIteratorTest {

    @Test

    public void testIteratorWithZeroDimensions() {

        CoordinateIterator iterator = new CoordinateIterator(0, 0);

        assertFalse(iterator.hasNext());

    }

    @Test

    public void testIteratorWithOneDimension() {

        CoordinateIterator iterator = new CoordinateIterator(5, 1);

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertFalse(iterator.hasNext());

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

    }

    @Test

    public void testIteratorWithTwoDimensions() {

        CoordinateIterator iterator = new CoordinateIterator(3, 2);

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertTrue(iterator.hasNext());

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

        assertFalse(iterator.hasNext());

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

    }

}

 No newline at end of file

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

+100
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import java.util.List;

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

public class CoordinateTest {

    @Test

    public void testCoordinateCreation() {

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

        assertEquals(3, coordinate.x());

        assertEquals(4, coordinate.y());

    }

    @Test

    public void testLeft() {

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

        Coordinate left = coordinate.left();

        assertEquals(2, left.x());

        assertEquals(4, left.y());

    }

    @Test

    public void testRight() {

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

        Coordinate right = coordinate.right();

        assertEquals(4, right.x());

        assertEquals(4, right.y());

    }

    @Test

    public void testAbove() {

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

        Coordinate above = coordinate.above();

        assertEquals(3, above.x());

        assertEquals(5, above.y());

    }

    @Test

    public void testBelow() {

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

        Coordinate below = coordinate.below();

        assertEquals(3, below.x());

        assertEquals(3, below.y());

    }

    @Test

    public void testOrthogonalNeighbours() {

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

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

        assertEquals(4, neighbours.size());

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

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

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

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

        assertFalse(neighbours.contains(coordinate));

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

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

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

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

    }

    @Test

    public void testDiagonalNeighbours() {

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

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

        assertEquals(4, neighbours.size());

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

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

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

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

        assertFalse(neighbours.contains(coordinate));

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

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

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

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

    }

    @Test

    public void testOrthodiagonalNeighbours() {

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

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

        assertEquals(8, neighbours.size());

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

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

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

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

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

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

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

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

        assertFalse(neighbours.contains(coordinate));

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

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

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

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

    }

}

 No newline at end of file

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

+100
−0

Original line number
Original line
Diff line number
Diff line

package matrix;

import org.junit.jupiter.api.Test;

import java.util.Iterator;

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

class ListMatrixTest {

    private final MatrixInitializer<Integer> sumInitializer =

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

    @Test

    public void testMatrixCreationWithInitializer() {

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

        assertEquals(3, matrix.width());

        assertEquals(4, matrix.height());

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

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

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

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

    }

    @Test

    public void testMatrixCreationWithInitialValue() {

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

        assertEquals(2, matrix.width());

        assertEquals(2, matrix.height());

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

    }

    @Test

    public void testMatrixSetAndGet() {

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

        matrix.set(1, 1,42);

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

        matrix.set(0, 2,10);

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

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

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

    }

    @Test

    public void testMatrixWidthAndHeight() {

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

        assertEquals(4, matrix.width());

        assertEquals(2, matrix.height());

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

        assertEquals(4, matrix.width());

        assertEquals(2, matrix.height());

    }

    @Test

    public void testMatrixIterator() {

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

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

        assertTrue(iterator.hasNext());

        assertEquals(0, iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(1, iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(1, iterator.next());

        assertTrue(iterator.hasNext());

        assertEquals(2, iterator.next());

        assertFalse(iterator.hasNext());

    }

    @Test

    public void testMatrixCoordinates() {

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

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

        int count = 0;

        for (Coordinate coord : coordinates) {

            count++;

        }

        assertEquals(4, count);

    }

    @Test

    public void testSubMatrix() {

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

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

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

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

        }

      }

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

      assertEquals(2, sub.width());

      assertEquals(3, sub.height());

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

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

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

        }

      }

    }

}

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

+40
−0

Original line number
Original line
Diff line number
Diff line

package model;

import org.junit.jupiter.api.Test;

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

class CellTest {

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

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

        private Change<T> lastChange = null;

        public boolean checksLastChange(T oldValue, T newValue) {

            return this.lastChange != null

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

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

        }

        @Override

        public void valueChanged(T oldValue, T newValue) {

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

        }

    }

    @Test

    public void testCellValueChangeWithListener() {

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

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

        cell.addOnChangeListener(mockListener);

        cell.set(99);

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

        assertEquals(99, cell.get());

    }

    @Test

    public void testCellWithoutListener() {

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

        cell.set("Bar");

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

    }

}

 No newline at end of file

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

+162
−0

Original line number
Original line
Diff line number
Diff line

package model;

import matrix.Coordinate;

import javafx.scene.paint.Color;

import model.automata.GameOfLifeAutomaton;

import static model.automata.GameOfLifeState.*;

import model.automata.GameOfLifeState;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Random;

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

class CellularAutomatonSimulationTest {

    private final CellularAutomatonSimulation<GameOfLifeState> simulation;

    private final CellularAutomaton<GameOfLifeState> automaton;

    private final Random randomGenerator;

    CellularAutomatonSimulationTest() {

        this.randomGenerator = new Random();

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

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

    }

    @BeforeEach

    public void setUp() {

        this.simulation.clear();

    }

    @Test

    public void testNumberOfColumns() {

        assertEquals(4, simulation.numberOfColumns());

    }

    @Test

    public void testNumberOfRows() {

        assertEquals(3, simulation.numberOfRows());

    }

    @Test

    public void testAt() {

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

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

        assertEquals(DEAD,cell.get());

    }

    @Test

    public void testUpdateToNextGeneration() {

        GameOfLifeState[][] input =

                { {ALIVE, ALIVE, ALIVE, DEAD},

                  {ALIVE, DEAD, DEAD, DEAD},

                  {DEAD, ALIVE, DEAD, DEAD}

                };

        GameOfLifeState[][] output =

                { {ALIVE, DEAD, ALIVE, ALIVE},

                  {ALIVE, DEAD, ALIVE, ALIVE},

                  {DEAD, DEAD, ALIVE, ALIVE}

                };

        for (Coordinate coordinate : this.simulation) {

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

        }

        simulation.updateToNextGeneration();

        for (Coordinate coordinate : this.simulation) {

            assertEquals(

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

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

                    "Generation at " + coordinate

            );

        }

    }

    @Test

    public void testNext() {

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

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

        GameOfLifeState oldState = cell.get();

        simulation.next(coordinate);

        assertNotEquals(oldState, cell.get());

    }

    @Test

    public void testCopy() {

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

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

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

        simulation.copy(source, destination);

        assertEquals(

                ALIVE,

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

        );

    }

    @Test

    public void testColor() {

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

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

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

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

    }

    @Test

    public void testSetChangeListener() {

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

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

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

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

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

        simulation.setChangeListener(coordinate, listener);

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

        assertEquals(Collections.emptyList(), states);

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

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

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

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

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

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

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

    }

    @Test

    public void testSetGenerationNumberChangeListener() {

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

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

        simulation.setGenerationNumberChangeListener(listener);

        assertEquals(Collections.emptyList(), values);

        simulation.clear();

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

        simulation.updateToNextGeneration();

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

        simulation.updateToNextGeneration();

        simulation.updateToNextGeneration();

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

    }

    @Test

    public void testClear() {

        for (Coordinate coordinate : this.simulation) {

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

        }

        this.simulation.clear();

        for (Coordinate coordinate : this.simulation) {

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

        }

    }

    @Test

    public void testReset() {

        randomGenerator.setSeed(321);

        this.simulation.reset();

        int count = 0;

        for (Coordinate coordinate : this.simulation) {

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

                count = count + 1;

            }

        }

        assertEquals(7, count);

    }

}

 No newline at end of file

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

+0
−50

Original line number
Original line
Diff line number
Diff line

package model;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

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

public class GridTest {

  private CellGrid grid;

//  @BeforeEach

//  public void initializeGrid() {

//    grid = new CellGrid(6, 6);

//  }

//

//  @Test

//  public void testGetNeighbours() {

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

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

//    assertThat(grid.getNeighbors(1, 1))

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

//                    grid.getCell(0, 1),

//                    grid.getCell(0, 2),

//                    grid.getCell(1, 0),

//                    grid.getCell(1, 2),

//                    grid.getCell(2, 0),

//                    grid.getCell(2, 1),

//                    grid.getCell(2, 2));

//  }

//

//  @Test

//  public void testCountAliveNeighbours() {

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

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

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

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

//  }

//

//  @Test

//  public void testCalculateNextState() {

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

//    grid.getCell(1, 1).setState(CellState.ALIVE);

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

//    assertThat(grid.calculateNextState(0, 0).isAlive).isFalse();

//    assertThat(grid.calculateNextState(1, 0).isAlive).isFalse();

//    assertThat(grid.calculateNextState(1, 1).isAlive).isTrue();

//    assertThat(grid.calculateNextState(2, 1).isAlive).isTrue();

//  }

}

 No newline at end of file

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

+81
−0

Original line number
Original line
Diff line number
Diff line

package model;

import matrix.Coordinate;

import model.automata.GameOfLifeAutomaton;

import model.automata.GameOfLifeState;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import java.util.Random;

import static model.automata.GameOfLifeState.ALIVE;

import static model.automata.GameOfLifeState.DEAD;

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

class NextGenerationInitializerTest {

    private final CellularAutomatonSimulation<GameOfLifeState> simulation =

            new CellularAutomatonSimulation<>(

                    new GameOfLifeAutomaton(4,3),

                    new Random()

                    );

    private final NextGenerationInitializer<GameOfLifeState> initializer =

            new NextGenerationInitializer<>(this.simulation);

    @BeforeEach

    public void prepareSimulation() {

        GameOfLifeState[][] state =

                { { DEAD, DEAD, DEAD, DEAD }

                , { ALIVE, ALIVE, DEAD, DEAD }

                , { DEAD, DEAD, ALIVE, DEAD }

                };

        for (Coordinate coordinate : this.simulation) {

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

        }

    }

    @Test

    void initialValueAt() {

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

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

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

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

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

    }

    @Test

    public void testWrapCoordinateInsideGrid() {

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

        Coordinate wrapped = initializer.wrap(coordinate);

        assertEquals(coordinate, wrapped);

    }

    @Test

    public void testWrapCoordinateOutsideGrid() {

        assertEquals(

                Coordinate.of(0, 1),

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

        );

        assertEquals(

                Coordinate.of(3, 2),

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

        );

         assertEquals(

                Coordinate.of(3, 2),

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

        );   }

    @Test

    public void testModuloPositive() {

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

        assertEquals(3, result);

    }

    @Test

    public void testModuloNegative() {

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

        assertEquals(1, result);

    }

}

 No newline at end of file

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

+39
−0

Original line number
Original line
Diff line number
Diff line

package model;

import org.junit.jupiter.api.Test;

import java.util.List;

import static model.State.count;

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

class StateTest {

    @Test

    public void testCountMethodWithInteger() {

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

        int result = count(1, neighbours);

        assertEquals(3, result);

    }

    @Test

    public void testCountMethodWithString() {

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

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

        assertEquals(3, result);

    }

    @Test

    public void testCountMethodWithEmptyList() {

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

        int result = count(5.0, neighbours);

        assertEquals(0, result);

    }

    @Test

    public void testCountMethodWithNoMatchingElements() {

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

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

        assertEquals(0, result);

    }

}

 No newline at end of file

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

+70
−0

Original line number
Original line
Diff line number
Diff line

package model.automata;

import javafx.scene.paint.Color;

import model.State;

import org.junit.jupiter.api.Test;

import java.util.List;

import static model.automata.GameOfLifeState.*;

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

class GameOfLifeStateTest {

    @Test

    public void testGetColor() {

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

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

    }

    @Test

    public void testNext() {

        assertEquals(ALIVE.next(), DEAD);

        assertEquals(DEAD.next(), ALIVE);

    }

    @Test

    public void testAliveUpdate() {

        // Test with three alive neighbors, should be ALIVE

        List<GameOfLifeState> aliveNeighbors =

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

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

        // Test with two alive neighbors, should be ALIVE

        List<GameOfLifeState> twoAliveNeighbors =

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

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

        // Test with four alive neighbors, should be DEAD

        List<GameOfLifeState> fourAliveNeighbors =

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

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

        // Test with zero alive neighbors, should be DEAD

        List<GameOfLifeState> zeroAliveNeighbors =

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

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

    }

    @Test

    public void testDeadUpdate() {

        // Test with three alive neighbors, should be ALIVE

        List<GameOfLifeState> aliveNeighbors =

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

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

        // Test with two alive neighbors, should be DEAD

        List<GameOfLifeState> twoAliveNeighbors =

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

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

        // Test with four alive neighbors, should be DEAD

        List<GameOfLifeState> fourAliveNeighbors =

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

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

        // Test with zero alive neighbors, should be DEAD

        List<GameOfLifeState> zeroAliveNeighbors =

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

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

    }

}

 No newline at end of file

Source

Target

Files