39f46b80d8b9c78a07f78ae3071e1adecaf2789a 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

+2
−3

Original line number
Original line
Diff line number
Diff line

@@ -7,8 +7,7 @@ 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.BiColorAutomaton;

import model.automata.GameOfLifeAutomaton;

import model.automata.SeedsAutomaton;

import java.io.IOException;

import java.io.IOException;

import java.net.URL;

import java.net.URL;

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

  public SimulatorApplication() {

  public SimulatorApplication() {

    this.simulation =

    this.simulation =

      new CellularAutomatonSimulation<>(

      new CellularAutomatonSimulation<>(

              new BiColorAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),

              new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),

              GENERATOR

              GENERATOR

      );

      );

  }

  }

src/main/java/controller/Controller.java

+1
−9

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

src/main/java/controller/Simulation.java

+1
−1

Original line number
Original line
Diff line number
Diff line

package controller;

package controller;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.scene.paint.Color;

import javafx.scene.paint.Color;

import model.OnChangeListener;

import model.OnChangeListener;

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

+0
−182

Original line number
Original line
Diff line number
Diff line

package datastruct;

import java.util.ArrayList;

import java.util.Iterator;

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 Matrix<T> implements Iterable<T> {

    private final List<List<T>> matrix;

    private final int width;

    private final int height;

    /**

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

     * values.

     *

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

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

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

     */

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

        this.width = width;

        this.height = height;

        this.matrix = new ArrayList<>();

        this.initializeWith(initializer);

    }

    /**

     * Creates a new {@link Matrix} with the specified width, height, and initial value for all

     * cells.

     *

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

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

     * @param initialValue The initial value to set in all cells of the {@link Matrix}.

     */

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

            }

        }

    }

    /**

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

     *

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

     */

    public int width() {

        return width;

    }

    /**

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

     *

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

     */

    public int height() {

        return height;

    }

    /**

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

     *

     * @param x The x-coordinate.

     * @param y The y-coordinate.

     * @return The value at the specified coordinates.

     */

    public T get(int x, int y) {

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

    }

    /**

     * Gets the value at the specified {@link Coordinate} in the {@link Matrix}.

     *

     * @param coordinate The {@link Coordinate}.

     * @return The value at the specified {@link Coordinate}.

     */

    public T get(Coordinate coordinate) {

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

    }

    /**

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

     *

     * @param x     The x-coordinate.

     * @param y     The y-coordinate.

     * @param value The value to set at the specified coordinates.

     */

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

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

    }

    /**

     * Sets the value at the specified {@link Coordinate} in the {@link Matrix}.

     *

     * @param coordinate The {@link Coordinate}.

     * @param value      The value to set at the specified {@link Coordinate}.

     */

    public void set(Coordinate coordinate, T value) {

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

    }

    /**

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

     */

    public Iterator<T> iterator() {

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

        return new MatrixIterator<>(this, coordIterator);

    }

    /**

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

     */

    public Iterable<Coordinate> coordinates() {

        return this::coordinatesIterator;

    }

    /**

     * Returns an {@link Iterator} that allows iterating over the {@link Coordinate}s in the

     * {@link Matrix} in row-major order.

     *

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

     */

    private Iterator<Coordinate> coordinatesIterator() {

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

    }

    /**

     * Returns a lens for accessing and modifying the value at the specified coordinates (x, y) in

     * the {@link Matrix}.

     *

     * @param x The x-coordinate.

     * @param y The y-coordinate.

     * @return A lens for the specified coordinates.

     */

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

            }

        };

    }

    /**

     * Returns a lens for accessing and modifying the value at the specified coordinate in the

     * {@link Matrix}.

     *

     * @param coordinate The {@link Coordinate}.

     * @return A lens for the specified  {@link Coordinate}.

     */

    public Lens<T> at(Coordinate coordinate) {

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

    }

}

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/datastruct/Coordinate.java→src/main/java/matrix/Coordinate.java

+52
−23

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

import java.util.ArrayList;

import java.util.List;

import java.util.List;

/**

/**

@@ -16,7 +15,8 @@ public record Coordinate(int x, int y) {

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

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

     */

     */

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

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

        return new Coordinate(x, y);

        // TODO: compléter ce fabriquant

        return null;

    }

    }

    /**

    /**

@@ -25,7 +25,8 @@ public record Coordinate(int x, int y) {

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

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

     */

     */

    public Coordinate left() {

    public Coordinate left() {

        return new Coordinate(x - 1, y);

        // TODO: à compléter

        return null;

    }

    }

    /**

    /**

@@ -34,7 +35,8 @@ public record Coordinate(int x, int y) {

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

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

     */

     */

    public Coordinate right() {

    public Coordinate right() {

        return new Coordinate(x + 1, y);

        // TODO: à compléter

        return null;

    }

    }

    /**

    /**

@@ -43,7 +45,8 @@ public record Coordinate(int x, int y) {

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

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

     */

     */

    public Coordinate above() {

    public Coordinate above() {

        return new Coordinate(x, y + 1);

        // TODO: à compléter

        return null;

    }

    }

    /**

    /**

@@ -52,50 +55,76 @@ public record Coordinate(int x, int y) {

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

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

     */

     */

    public Coordinate below() {

    public Coordinate below() {

        return new Coordinate(x, y - 1);

        // TODO: à compléter

        return null;

    }

    }

    /**

    /**

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

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

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

     */

     */

    public List<Coordinate> orthogonalNeighbours() {

    public List<Coordinate> orthogonalNeighbours() {

        return List.of(

        // TODO: à compléter

                this.right(),

        return List.of();

                this.left(),

                this.above(),

                this.below()

        );

    }

    }

    /**

    /**

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

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

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

     */

     */

    public List<Coordinate> diagonalNeighbours() {

    public List<Coordinate> diagonalNeighbours() {

        return List.of(

        // TODO: à compléter

                this.right().above(),

        return List.of();

                this.left().above(),

                this.left().below(),

                this.right().below()

        );

    }

    }

    /**

    /**

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

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

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

     */

     */

    public List<Coordinate> orthodiagonalNeighbours() {

    public List<Coordinate> orthodiagonalNeighbours() {

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

        // TODO: à compléter

        neighbours.addAll(this.diagonalNeighbours());

        return List.of();

        return neighbours;

    }

    }

    @Override

    @Override

    public String toString() {

    public String toString() {

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

        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/datastruct/CoordinateIterator.java→src/main/java/matrix/CoordinateIterator.java

+6
−18

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;

@@ -8,10 +8,6 @@ import java.util.NoSuchElementException;

 * height range.

 * height range.

 */

 */

class CoordinateIterator implements Iterator<Coordinate> {

class CoordinateIterator implements Iterator<Coordinate> {

    private final int width;

    private final int height;

    private int x = 0;

    private int y = 0;

    /**

    /**

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

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

@@ -20,8 +16,7 @@ class CoordinateIterator implements Iterator<Coordinate> {

     * @param height The height of the coordinate range.

     * @param height The height of the coordinate range.

     */

     */

    public CoordinateIterator(int width, int height) {

    public CoordinateIterator(int width, int height) {

        this.width = width;

        // TODO: à compléter

        this.height = height;

    }

    }

    /**

    /**

@@ -31,7 +26,8 @@ class CoordinateIterator implements Iterator<Coordinate> {

     */

     */

    @Override

    @Override

    public boolean hasNext() {

    public boolean hasNext() {

        return y < this.height;

        // TODO: à compléter

        return false;

    }

    }

    /**

    /**

@@ -42,15 +38,7 @@ class CoordinateIterator implements Iterator<Coordinate> {

     */

     */

    @Override

    @Override

    public Coordinate next() {

    public Coordinate next() {

        if (!this.hasNext()) {

        // TODO: à compléter

            throw new NoSuchElementException();

        return null;

        }

        Coordinate coordinate = 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 coordinate;

    }

    }

}

}

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/datastruct/MatrixInitializer.java→src/main/java/matrix/MatrixInitializer.java

+4
−4

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

/**

/**

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

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

 *

 *

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

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

 */

 */

public interface MatrixInitializer<T> {

public interface MatrixInitializer<T> {

    /**

    /**

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

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

     * {@link Coordinate}.

     * {@link Coordinate}.

     *

     *

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

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

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

+9
−10

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;

@@ -12,7 +10,10 @@ import java.util.List;

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

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

@@ -20,7 +21,7 @@ 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.

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

@@ -39,11 +40,8 @@ public class Cell<T> implements Lens<T> {

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

        T oldValue = this.content;

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

        this.content = value;

        // listeners

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

            listener.valueChanged(oldValue, value);

        }

    }

    }

    /**

    /**

@@ -52,6 +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/CellularAutomatonSimulation.java

+21
−32

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.scene.paint.Color;

import javafx.scene.paint.Color;

import java.util.Iterator;

import java.util.Iterator;

@@ -18,7 +18,7 @@ import java.util.Random;

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 Cell<Integer> generationNumber = new Cell<>(0);

    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;

@@ -31,7 +31,7 @@ public class CellularAutomatonSimulation<S extends State<S>>

     */

     */

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

@@ -42,12 +42,14 @@ public class CellularAutomatonSimulation<S extends State<S>>

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

    }

    }

    /**

    /**

@@ -57,45 +59,38 @@ public class CellularAutomatonSimulation<S extends State<S>>

     * @return The cell at the specified coordinate.

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

    @Override

    public void updateToNextGeneration() {

    public void updateToNextGeneration() {

        this.generationNumber.set(this.generationNumber.get()+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<>(

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

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

        //TODO: à compléter

        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

@@ -113,19 +108,13 @@ public class CellularAutomatonSimulation<S extends State<S>>

    @Override

    @Override

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

    }

    }

    @Override

    @Override

    public void reset() {

    public void reset() {

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

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

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

        }

        this.generationNumber.set(0);

    }

    }

    @Override

    @Override

src/main/java/model/ConstantCellInitializer.java

+8
−7

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.ListMatrix;

import datastruct.MatrixInitializer;

import matrix.MatrixInitializer;

/**

/**

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

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

 *  same value.

 *  same value.

 *

 *

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

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

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

     * value.

     * value.

@@ -19,11 +19,12 @@ public class ConstantCellInitializer<T>  implements MatrixInitializer<Cell<T>> {

     * @param defaultValue the value stored in each cell.

     * @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/datastruct/Lens.java→src/main/java/model/Lens.java

+1
−1

Original line number
Original line
Diff line number
Diff line

package datastruct;

package model;

/**

/**

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

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

src/main/java/model/NextGenerationInitializer.java

+14
−21

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.MatrixInitializer;

import datastruct.Matrix;

import matrix.ListMatrix;

import controller.Simulation;

import controller.Simulation;

import java.util.ArrayList;

import java.util.List;

/**

/**

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

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

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

 *

 *

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

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

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

     * a 2D cellular automaton.

     * a 2D cellular automaton.

@@ -23,18 +21,13 @@ public class NextGenerationInitializer<S extends State<S>> implements MatrixInit

     * @param simulation the {@link Simulation} representing the 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);

    }

    }

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

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

@@ -45,11 +38,11 @@ public class NextGenerationInitializer<S extends State<S>> implements MatrixInit

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

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

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

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

     */

     */

    private Coordinate wrap(Coordinate coordinate) {

    Coordinate wrap(Coordinate coordinate) {

        return new Coordinate(

        //TODO: à compléter

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

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

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

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

@@ -58,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

+2
−7

Original line number
Original line
Diff line number
Diff line

@@ -44,12 +44,7 @@ public interface State<S> {

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

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

     */

     */

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

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

        int count = 0;

        //TODO: à compléter

        for (T neighbour : neighbours) {

        return 0;

            if (neighbour.equals(state)) {

                count++;

            }

        }

        return count;

    }

    }

}

}

 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
−23

Original line number
Original line
Diff line number
Diff line

package model.automata;

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
−45

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;

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<BiColorState> neighbours) {

        int countBlue = State.count(BLUE, neighbours);

        int countRed = State.count(RED, neighbours);

        int countAlive = countBlue + countRed;

        if (this == DEAD) {

            return (countAlive != 3)? DEAD:

                    countBlue > countRed? BLUE:

                            RED;

        }

        return 2 <= countAlive && countAlive <= 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
−42

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;

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<BriansBrainState> neighbours) {

        return switch (this) {

            case ON -> DYING;

            case DYING -> OFF;

            case OFF -> {

                int count = State.count(ON, neighbours);

                yield count==2 ? ON : OFF;

            }

        };

    }

}

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

+20
−6

Original line number
Original line
Diff line number
Diff line

package model.automata;

package model.automata;

import model.CellularAutomaton;

import java.util.Random;

import java.util.Random;

public class GameOfLifeAutomaton extends AbstractAutomaton<GameOfLifeState> {

public class GameOfLifeAutomaton implements CellularAutomaton<GameOfLifeState> {

    public 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

+7
−13

Original line number
Original line
Diff line number
Diff line

@@ -9,31 +9,25 @@ import java.util.List;

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

    public GameOfLifeState update(List<GameOfLifeState> neighbours) {

        int countAlive = State.count(ALIVE, neighbours);

        //TODO: à compléter

        return (countAlive == 3 || this == ALIVE && countAlive == 2)?

        return null;

                 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(10) == 0?

                SeedsState.ON:

                SeedsState.OFF;

    }

}

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

+0
−35

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;

public enum SeedsState implements State<SeedsState> {

    ON, OFF;

    @Override

    public Color getColor() {

        return switch (this) {

            case ON -> Color.GOLD;

            case OFF -> Color.BLACK;

        };

    }

    @Override

    public SeedsState next() {

        return switch (this) {

            case ON -> OFF;

            case OFF -> ON;

        };

    }

    @Override

    public SeedsState update(List<SeedsState> neighbours) {

        return switch (this) {

            case ON -> OFF;

            case OFF -> State.count(ON,neighbours) == 2 ? ON: OFF;

        };

    }

}

src/main/java/view/FillingMouseListener.java

+1
−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;

public class FillingMouseListener implements MouseListener {

public class FillingMouseListener implements MouseListener {

src/main/java/view/MatrixPane.java

+1
−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;

src/main/java/view/MouseListener.java

+1
−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 {

src/main/java/view/WaitingMouseListener.java

+1
−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;

class WaitingMouseListener implements MouseListener {

class WaitingMouseListener implements MouseListener {

src/test/java/datastruct/ConstantMatrixInitializerTest.java→src/test/java/matrix/ConstantMatrixInitializerTest.java

+3
−3

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.Test;

@@ -7,7 +7,7 @@ import static org.junit.jupiter.api.Assertions.*;

class ConstantMatrixInitializerTest {

class ConstantMatrixInitializerTest {

    @Test

    @Test

    public void testMatrixInitializationWithConstantValue() {

    public void testMatrixInitializationWithConstantValue() {

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

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

        // Test that all cells have the constant value.

        // Test that all cells have the constant value.

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

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

@@ -19,7 +19,7 @@ class ConstantMatrixInitializerTest {

    @Test

    @Test

    public void testMatrixInitializationWithConstantValue2() {

    public void testMatrixInitializationWithConstantValue2() {

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

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

        // Test that all cells have the constant value.

        // Test that all cells have the constant value.

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

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

src/test/java/datastruct/CoordinateIteratorTest.java→src/test/java/matrix/CoordinateIteratorTest.java

+1
−1

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.Test;

src/test/java/datastruct/CoordinateTest.java→src/test/java/matrix/CoordinateTest.java

+1
−1

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.Test;

src/test/java/datastruct/MatrixTest.java→src/test/java/matrix/ListMatrixTest.java

+30
−18

Original line number
Original line
Diff line number
Diff line

package datastruct;

package matrix;

import org.junit.jupiter.api.Test;

import org.junit.jupiter.api.Test;

@@ -6,14 +6,14 @@ import java.util.Iterator;

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

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

class MatrixTest {

class ListMatrixTest {

    private final MatrixInitializer<Integer> sumInitializer =

    private final MatrixInitializer<Integer> sumInitializer =

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

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

    @Test

    @Test

    public void testMatrixCreationWithInitializer() {

    public void testMatrixCreationWithInitializer() {

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

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

        assertEquals(3, matrix.width());

        assertEquals(3, matrix.width());

        assertEquals(4, matrix.height());

        assertEquals(4, matrix.height());

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

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

@@ -24,7 +24,7 @@ class MatrixTest {

    @Test

    @Test

    public void testMatrixCreationWithInitialValue() {

    public void testMatrixCreationWithInitialValue() {

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

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

        assertEquals(2, matrix.width());

        assertEquals(2, matrix.width());

        assertEquals(2, matrix.height());

        assertEquals(2, matrix.height());

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

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

@@ -32,7 +32,7 @@ class MatrixTest {

    @Test

    @Test

    public void testMatrixSetAndGet() {

    public void testMatrixSetAndGet() {

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

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

        matrix.set(1, 1,42);

        matrix.set(1, 1,42);

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

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

        matrix.set(0, 2,10);

        matrix.set(0, 2,10);

@@ -43,7 +43,7 @@ class MatrixTest {

    @Test

    @Test

    public void testMatrixWidthAndHeight() {

    public void testMatrixWidthAndHeight() {

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

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

        assertEquals(4, matrix.width());

        assertEquals(4, matrix.width());

        assertEquals(2, matrix.height());

        assertEquals(2, matrix.height());

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

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

@@ -53,7 +53,7 @@ class MatrixTest {

    @Test

    @Test

    public void testMatrixIterator() {

    public void testMatrixIterator() {

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

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

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

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

        assertTrue(iterator.hasNext());

        assertTrue(iterator.hasNext());

        assertEquals(0, iterator.next());

        assertEquals(0, iterator.next());

@@ -68,7 +68,7 @@ class MatrixTest {

    @Test

    @Test

    public void testMatrixCoordinates() {

    public void testMatrixCoordinates() {

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

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

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

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

        int count = 0;

        int count = 0;

        for (Coordinate coord : coordinates) {

        for (Coordinate coord : coordinates) {

@@ -77,12 +77,24 @@ class MatrixTest {

        assertEquals(4, count);

        assertEquals(4, count);

    }

    }

    @Test

    @Test

    public void testMatrixLens() {

    public void testSubMatrix() {

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

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

        Lens<Integer> lens = matrix.at(1, 1);

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

        assertEquals(0, lens.get());

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

        lens.set(42);

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

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

        }

      }

      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/CellularAutomatonSimulationTest.java

+1
−1

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import datastruct.Coordinate;

import matrix.Coordinate;

import javafx.scene.paint.Color;

import javafx.scene.paint.Color;

import model.automata.GameOfLifeAutomaton;

import model.automata.GameOfLifeAutomaton;

import static model.automata.GameOfLifeState.*;

import static model.automata.GameOfLifeState.*;

src/test/java/model/NextGenerationInitializerTest.java

+1
−2

Original line number
Original line
Diff line number
Diff line

package model;

package model;

import controller.Simulation;

import matrix.Coordinate;

import datastruct.Coordinate;

import model.automata.GameOfLifeAutomaton;

import model.automata.GameOfLifeAutomaton;

import model.automata.GameOfLifeState;

import model.automata.GameOfLifeState;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.BeforeEach;

Source

Target

Files