Skip to content
Snippets Groups Projects

Compare revisions

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

Source

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

Target

Select target project
  • s20026898/tp-6
  • boukenze.b/jeu-de-la-vie-tp-3
  • b22015696/game-of-life-template
  • s23026062/sahin-game-of-life-template
  • m22023183/game-of-life-MALEK
  • z23012739/game-of-life-template
  • p23021107/poussardin-malo-game-of-life-template
  • o21225801/game-of-life-template
  • alaboure/game-fo-life-template
  • t22007439/game-of-life-toullec
  • b23021750/game-of-life
  • c22029830/game-of-life-template-rafi
  • b23025683/game-of-life-template-tp-6
  • gnaves/game-of-life-template
  • a22025223/game-of-life-template-cristel
  • f22024692/game-of-life-template-paolo-mathis-erwan
  • t21233923/game-fo-life-template
  • h21231335/game-fo-life-template
  • l22023519/game-of-life-template-salma
  • p23020787/game-of-life-template
  • b21232450/game-of-life-template
  • s22031458/game-of-life
  • n21223697/tp-4-ngom
  • a22027291/game-of-life-of-salim
  • k22029508/tp-4
  • s19033421/game-of-life-template
  • b21229750/jeu-de-la-vie-tp-3
  • saddem.r/game-of-life-template
  • l3_s3_infoamu/s3/programmation-2/game-fo-life-template
29 results
Select Git revision
  • ImprovedMouseInteraction
  • correction_video
  • going_further
  • main
  • ModifGUI
  • final2023
  • template
7 results
Show changes
Commits on Source (7)
Showing
with 525 additions and 298 deletions
......@@ -4,7 +4,7 @@ plugins {
}
javafx {
version = "20"
version = "22"
modules = [ 'javafx.controls', 'javafx.fxml' ]
}
......
distributionBase=GRADLE_USER_HOME
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
zipStorePath=wrapper/dists
......@@ -7,16 +7,12 @@ import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import model.CellularAutomatonSimulation;
import model.automata.BriansBrainAutomaton;
import model.automata.GameOfLifeAutomaton;
import model.automata.SeedsAutomaton;
import java.io.IOException;
import java.net.URL;
import java.util.Random;
import static java.util.Objects.requireNonNull;
/**
* Entry point for <i>The Game of Life</i> application.
*
......@@ -41,7 +37,7 @@ public class SimulatorApplication extends Application {
public SimulatorApplication() {
this.simulation =
new CellularAutomatonSimulation<>(
new SeedsAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),
new GameOfLifeAutomaton(NUMBER_OF_COLUMNS,NUMBER_OF_ROWS),
GENERATOR
);
}
......
package controller;
import datastruct.Coordinate;
import matrix.Coordinate;
import javafx.animation.Animation;
import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
......@@ -11,7 +11,6 @@ import javafx.scene.control.Label;
import javafx.scene.control.ToggleButton;
import javafx.scene.control.ToggleGroup;
import javafx.util.Duration;
import model.CellularAutomatonSimulation;
import view.MatrixPane;
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) {
this.simulation = requireNonNull(simulation, "game of life is null");
setGenerationNumberLabelTextProperty();
......@@ -65,7 +57,14 @@ public class Controller {
}
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() {
......
package controller;
import datastruct.Coordinate;
import javafx.beans.property.ReadOnlyLongProperty;
import matrix.Coordinate;
import javafx.scene.paint.Color;
import model.OnChangeListener;
/**
* Represents a simulation of a 2D cellular automaton, such as the Game of Life.
* Provides methods for updating the simulation, retrieving information, and managing listeners.
*/
public interface Simulation extends Iterable<Coordinate> {
/**
* Returns the number of columns in the simulation grid.
*
* @return The number of columns in the grid.
*/
int numberOfColumns();
/**
* Returns the number of rows in the simulation grid.
*
* @return The number of rows in the grid.
*/
int numberOfRows();
/**
* Updates the simulation to the next generation. This is done by computing, for each
* coordinate, a new state that depends on the states of its neighbours.
*/
void updateToNextGeneration();
/**
* Changes the state at a given {@link Coordinate}. This is used to edit the grid with the mouse. It
* is not part of the simulation of the cellular automaton.
*
* @param coordinate The {@link Coordinate} to advance to the next state.
*/
void next(Coordinate coordinate);
/**
* Copies the state from the source {@link Coordinate} to the destination {@link Coordinate}.
*
* @param source The source {@link Coordinate}.
* @param destination The destination {@link Coordinate}.
*/
void copy(Coordinate source, Coordinate destination);
/**
* Gets the {@link Color} associated with the state at the specified {@link Coordinate}.
*
* @param coordinate The {@link Coordinate} to retrieve the color for.
* @return The {@link Color} associated with the state at the specified {@link Coordinate}.
*/
Color getColor(Coordinate coordinate);
/**
* Sets a listener to be executed when the state at the specified {@link Coordinate} changes.
*
* @param coordinate The {@link Coordinate} to listen for changes.
* @param listener The listener to execute when the state changes.
*/
void setChangeListener(Coordinate coordinate, Runnable listener);
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();
/**
* Clears the simulation, setting all states to their default values.
*/
void clear();
}
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;
}
}
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;
}
}
package datastruct;
public interface Lens<S> {
S get();
void set(S value);
}
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());
}
}
package datastruct;
public interface MatrixInitializer<T> {
T initialValueAt(Coordinate coordinate);
}
package datastruct;
package matrix;
public class ConstantMatrixInitializer<T> implements MatrixInitializer<T> {
private final T constant;
// TODO: add instance variables
public ConstantMatrixInitializer(T constant) {
// TODO
}
public ConstantMatrixInitializer(T constant) {
this.constant = constant;
}
@Override
public T initialValueAt(Coordinate coordinate) {
return constant;
// TODO
return null;
}
}
package matrix;
import java.util.List;
/**
* Represents a 2D integer coordinate used to specify positions in a grid.
*/
public record Coordinate(int x, int y) {
/**
* Creates a new {@link Coordinate} instance with the given {@code x} and {@code y} values.
*
* @param x The x-coordinate value.
* @param y The y-coordinate value.
* @return A new {@link Coordinate} instance.
*/
public static Coordinate of(int x, int y) {
// TODO: compléter ce fabriquant
return null;
}
/**
* Computes and returns the {@link Coordinate} to the left of this one.
*
* @return The left adjacent {@link Coordinate}.
*/
public Coordinate left() {
// TODO: à compléter
return null;
}
/**
* Computes and returns the {@link Coordinate} to the right of this one.
*
* @return The right adjacent {@link Coordinate}.
*/
public Coordinate right() {
// TODO: à compléter
return null;
}
/**
* Computes and returns the {@link Coordinate} above this one.
*
* @return The above adjacent {@link Coordinate}.
*/
public Coordinate above() {
// TODO: à compléter
return null;
}
/**
* Computes and returns the {@link Coordinate} below this one.
*
* @return The below adjacent {@link Coordinate}.
*/
public Coordinate below() {
// TODO: à compléter
return null;
}
/**
* Computes and returns a list of orthogonal (adjacent in horizontal or vertical direction) neighbors.
* | | | |
* ---------
* | |X| |
* ---------
* |X|O|X|
* ---------
* | |X| |
* ---------
* | | | |
* @return A list of orthogonal neighboring {@link Coordinate}s.
*/
public List<Coordinate> orthogonalNeighbours() {
// TODO: à compléter
return List.of();
}
/**
* Computes and returns a list of diagonal (adjacent in diagonal direction) neighbors.
* | | | |
* ---------
* |X| |X|
* ---------
* | |O| |
* ---------
* |X| |X|
* ---------
* | | | |
*
* @return A list of diagonal neighboring {@link Coordinate}s.
*/
public List<Coordinate> diagonalNeighbours() {
// TODO: à compléter
return List.of();
}
/**
* Computes and returns a list of all orthogonal and diagonal neighbors.
* * | | | |
* * ---------
* * |X|X|X|
* * ---------
* * |X|O|X|
* * ---------
* * |X|X|X|
* * ---------
* * | | | |
*
* @return A list of all neighboring {@link Coordinate}s.
*/
public List<Coordinate> orthodiagonalNeighbours() {
// TODO: à compléter
return List.of();
}
@Override
public String toString() {
return "(" + this.x + "," + this.y + ")";
}
public Coordinate minus(Coordinate corner) {
return new Coordinate(this.x - corner.x, this.y - corner.y);
}
public Coordinate plus(Coordinate corner) {
return new Coordinate(this.x + corner.x, this.y + corner.y);
}
}
\ No newline at end of file
package matrix;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* An {@link Iterator} for generating 2D {@link Coordinate}s within a specified width and
* height range.
*/
class CoordinateIterator implements Iterator<Coordinate> {
/**
* Creates a new {@link CoordinateIterator} with the specified width and height.
*
* @param width The width of the coordinate range.
* @param height The height of the coordinate range.
*/
public CoordinateIterator(int width, int height) {
// TODO: à compléter
}
/**
* Checks if there are more {@link Coordinate}s to iterate over.
*
* @return true if there are more {@link Coordinate}s; otherwise, false.
*/
@Override
public boolean hasNext() {
// TODO: à compléter
return false;
}
/**
* Returns the next {@link Coordinate} in the iteration.
*
* @return The next {@link Coordinate} in the iteration.
* @throws NoSuchElementException if there are no more {@link Coordinate}s to iterate over.
*/
@Override
public Coordinate next() {
// TODO: à compléter
return null;
}
}
package matrix;
import java.util.List;
/**
* Represents a matrix, a rectangular array, with generic values in each cell.
*
* @param <T> The type of values stored in the matrix cells.
*/
public class ListMatrix<T> implements Matrix<T> {
private final List<List<T>> matrix;
private final int width;
private final int height;
/**
* Creates a new {@link ListMatrix} with the specified width, height, and an initializer to set
* values.
*
* @param width The width of the {@link ListMatrix}.
* @param height The height of the {@link ListMatrix}.
* @param initializer A matrix initializer to set values in the {@link ListMatrix}.
*/
public ListMatrix(int width, int height, MatrixInitializer<T> initializer) {
// TODO
this.width = 0;
this.height = 0;
this.matrix = null;
this.initializeWith(initializer); // fills the matrix using initializer
}
public ListMatrix(int width, int height, T constant) {
this(width, height, new ConstantMatrixInitializer<>(constant));
}
private void initializeWith(MatrixInitializer<T> initializer) {
// TODO initialize each cell of the matrix, with a value determined by initializer
}
public int width() {
// TODO
return 0;
}
public int height() {
// TODO
return 0;
}
@Override
public T get(int x, int y) {
// TODO
return null;
}
@Override
public void set(int x, int y, T newValue) {
// TODO
}
public Matrix<T> subMatrix(Coordinate corner, int width, int height) {
// TODO
return this;
}
}
package matrix;
import java.util.Iterator;
public interface Matrix<T> extends Iterable<T> {
/**
* Returns the width of the {@link Matrix}.
*
* @return The width of the {@link Matrix}.
*/
int width();
/**
* Returns the height of the {@link Matrix}.
*
* @return The height of the {@link Matrix}.
*/
int height();
/**
* Returns the value at the specified coordinates (x, y) in
* the {@link Matrix}.
*
* @param x The x-coordinate.
* @param y The y-coordinate.
* @return The content of the matrix at the coordinates (x,y).
*/
T get(int x, int y);
/**
* Returns the value at the specified coordinates (x, y) in
* the {@link Matrix}.
*
* @param coordinate The coordinates (x,y).
* @return The content of the matrix at the coordinates (x,y).
*/
default T get(Coordinate coordinate) {
return this.get(coordinate.x(), coordinate.y());
}
/**
* Changes the value at the specified coordinates (x,y) in the {@link Matrix}
*
* @param x the x-coordinate
* @param y the y-coordinate
* @param newValue the value to assign to coordinates (x,y).
*/
void set(int x, int y, T newValue);
/**
* Changes the value at the specified coordinates (x,y) in the {@link Matrix}
*
* @param coordinate The coordinates (x,y)
* @param newValue the value to assign to coordinates (x,y).
*/
default void set(Coordinate coordinate, T newValue) {
this.set(coordinate.x(), coordinate.y(), newValue);
}
Matrix<T> subMatrix(Coordinate corner, int width, int height);
/**
* Returns an {@link Iterable} that provides access to the {@link Coordinate}s of the
* {@link Matrix} in row-major order. This means that a {@code for} loop on a {@link Matrix}
* will loop over the coordinates of the {@link Matrix}.
*
* @return An {@link Iterable} for the {@link Coordinate}s of the {@link Matrix}.
*/
default Iterable<Coordinate> coordinates() {
return () -> new CoordinateIterator(this.width(), this.height());
}
/**
* Returns an {@link Iterator} that allows iterating over the elements in the {@link Matrix} in
* row-major order.
*
* @return An {@link Iterator} for the {@link Matrix}.
*/
default Iterator<T> iterator() {
Iterator<Coordinate> coords =
new CoordinateIterator(this.width(),this.height());
return new MatrixIterator<>(this, coords);
}
}
package matrix;
/**
* An interface for initializing a {@link ListMatrix} by providing initial values for each cell.
*
* @param <T> The type of values to initialize the {@link ListMatrix} with.
*/
public interface MatrixInitializer<T> {
/**
* Returns the initial value to be set in a {@link ListMatrix} cell at the specified
* {@link Coordinate}.
*
* @param coordinate The {@link Coordinate} at which to set the initial value.
* @return The initial value for the specified cell.
*/
T initialValueAt(Coordinate coordinate);
}
package datastruct;
package matrix;
import java.util.Iterator;
import java.util.NoSuchElementException;
......
package model;
import datastruct.Lens;
import java.util.ArrayList;
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> {
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<>();
/** 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.
*/
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) {
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}
*/
public void set(T value) {
this.content = value;
for (OnChangeListener<T> listener : this.listeners) {
listener.valueChanged(this.content, value);
}
//TODO: modifier le contenu de la cellule, puis appeler les méthodes valueChanged des
// listeners
}
/**
......@@ -43,8 +50,7 @@ public class Cell<T> implements Lens<T> {
* @return the current content of this {@link Cell}
*/
public T get(){
return this.content;
//TODO: à compléter
return null;
}
}
......@@ -2,9 +2,41 @@ package model;
import java.util.Random;
/**
* Represents a cellular automaton, which defines the main parameters of a cellular automaton.
* The rules for updating states are defined in the class used as {@code S}.
*
* @param <S> The type of state used in the cellular automaton.
*/
public interface CellularAutomaton<S extends State<S>> {
/**
* Returns the number of columns in the grid of the cellular automaton.
*
* @return The number of columns in the grid.
*/
int numberOfColumns();
/**
* Returns the number of rows in the grid of the cellular automaton.
*
* @return The number of rows in the grid.
*/
int numberOfRows();
/**
* Returns the default state that is used to initialize cells in the automaton.
*
* @return The default state for cells in the automaton.
*/
S defaultState();
/**
* Generates a random state using the specified random number generator.
*
* @param generator The random number generator to use.
* @return A randomly generated state.
*/
S randomState(Random generator);
}
}
\ No newline at end of file
package model;
import controller.Simulation;
import datastruct.Coordinate;
import datastruct.Matrix;
import javafx.beans.property.ReadOnlyLongProperty;
import javafx.beans.property.ReadOnlyLongWrapper;
import matrix.Coordinate;
import matrix.ListMatrix;
import javafx.scene.paint.Color;
import java.util.Iterator;
import java.util.Random;
import java.util.function.Supplier;
/**
* {@link CellularAutomatonSimulation} instances run <i>The Game of Life</i>.
*
* @param <S> The type of state used in the simulation.
*/
public class CellularAutomatonSimulation<S extends State<S>>
implements Simulation {
private final Matrix<Cell<S>> grid;
private final ReadOnlyLongWrapper generationNumber = new ReadOnlyLongWrapper();
private final ListMatrix<Cell<S>> grid;
private final Cell<Integer> generationNumber = new Cell<>(0);
private final CellularAutomaton<S> automaton;
private final Random generator;
/**
* Creates a new {@link CellularAutomatonSimulation} instance for a given automaton.
*
* @param automaton a description of the {@link CellularAutomaton}
* @param automaton A description of the {@link CellularAutomaton}.
* @param generator The {@link Random} instance used for random state generation.
*/
public CellularAutomatonSimulation(CellularAutomaton<S> automaton, Random generator) {
this.automaton = automaton;
this.grid = new Matrix<>(
this.grid = new ListMatrix<>(
automaton.numberOfColumns(),
automaton.numberOfRows(),
new ConstantCellInitializer<>(automaton.defaultState())
......@@ -38,68 +39,58 @@ public class CellularAutomatonSimulation<S extends State<S>>
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
public int numberOfColumns() {
return this.grid.width();
//TODO: à compléter
return 0;
}
@Override
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) {
return this.grid.get(coordinate);
//TODO: à compléter
return null;
}
@Override
public void updateToNextGeneration() {
this.generationNumber.set(getGenerationNumber() + 1);
Matrix<S> nextStates = this.nextGenerationMatrix();
for (Coordinate coordinate : this.grid.coordinates()) {
this.at(coordinate).set(nextStates.get(coordinate));
}
//TODO: à compléter, en utilisant nextGenerationMatrix()
}
/** 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.
*
* @return the states of each cell after one generation
*/
private Matrix<S> nextGenerationMatrix() {
return new Matrix<S>(
this.grid.width(),
this.grid.height(),
new NextGenerationInitializer<>(this)
);
private ListMatrix<S> nextGenerationMatrix() {
//TODO: à compléter
return null;
}
@Override
public void next(Coordinate coordinate) {
S oldState = this.grid.get(coordinate).get();
this.at(coordinate).set(oldState.next());
//TODO: à compléter
}
@Override
public void copy(Coordinate source, Coordinate destination) {
System.out.println("bip (" + source + ") (" + destination + ")");
S state = this.at(source).get();
this.at(destination).set(state);
//TODO: à compléter
}
@Override
public Color getColor(Coordinate coordinate) {
return this.at(coordinate).get().getColor();
//TODO: à compléter
return null;
}
@Override
......@@ -109,42 +100,21 @@ public class CellularAutomatonSimulation<S extends State<S>>
);
}
/**
* Returns the current generationNumber.
*
* @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
public void setGenerationNumberChangeListener(OnChangeListener<Integer> listener){
this.generationNumber.addOnChangeListener(listener);
}
/**
* Clears the current game.
*/
@Override
public void clear() {
for (Cell<S> cell : this.grid) {
cell.set(this.automaton.defaultState());
}
this.generationNumber.set(0);
//TODO: à compléter (penser à remettre le nombre de génération à 0)
}
/**
* Clears the current game and randomly generates a new one.
*/
@Override
public void reset() {
this.clear();
this.fillRandomly(this.generator);
//TODO: à compléter (penser à remettre le nombre de génération à 0)
}
@Override
......