TP

src/main/java/model/automata/BiColorGameOfLifeAutomaton.java

+package model.automata;
+import model.CellularAutomaton;
+
+import java.util.Random;
+
+public class BiColorGameOfLifeAutomaton implements CellularAutomaton<BiColorGameOfLifeState> {
+    private final int rows;
+    private final int columns;
+
+    public BiColorGameOfLifeAutomaton(int rows, int columns) {
+        this.rows = rows;
+        this.columns = columns;
+    }
+
+    @Override
+    public int numberOfColumns() {
+        return columns;
+    }
+
+    @Override
+    public int numberOfRows() {
+        return rows;
+    }
+
+    @Override
+    public BiColorGameOfLifeState defaultState() {
+        return new BiColorGameOfLifeState(BiColorGameOfLifeState.StateType.DEAD);
+    }
+
+    @Override
+    public BiColorGameOfLifeState randomState(Random generator) {
+        return generator.nextDouble() < 0.5
+                ? new BiColorGameOfLifeState(BiColorGameOfLifeState.StateType.DEAD)
+                : (generator.nextDouble() < 0.5
+                ? new BiColorGameOfLifeState(BiColorGameOfLifeState.StateType.ALIVE_RED)
+                : new BiColorGameOfLifeState(BiColorGameOfLifeState.StateType.ALIVE_BLUE));
+    }
+}
\ No newline at end of file

src/main/java/model/automata/BiColorGameOfLifeState.java

+package model.automata;
+import javafx.scene.paint.Color;
+import model.State;
+
+import java.util.List;
+public class BiColorGameOfLifeState implements State<BiColorGameOfLifeState> {
+    public enum StateType {
+        DEAD,
+        ALIVE_RED,
+        ALIVE_BLUE }
+
+    private final StateType currentState;
+
+    public BiColorGameOfLifeState(StateType state) {
+        this.currentState = state;
+    }
+
+    @Override
+    public Color getColor() {
+        return switch (currentState) {
+            case DEAD -> Color.WHITE;
+            case ALIVE_RED -> Color.RED;
+            case ALIVE_BLUE -> Color.BLUE;
+        };
+    }
+    @Override
+    public BiColorGameOfLifeState next() {
+        return new BiColorGameOfLifeState(currentState == StateType.ALIVE_RED ? StateType.ALIVE_BLUE : StateType.ALIVE_RED);
+    }
+    @Override
+    public BiColorGameOfLifeState update(List<BiColorGameOfLifeState> neighbours) {
+        int redCount = State.count(new BiColorGameOfLifeState(StateType.ALIVE_RED), neighbours);
+        int blueCount = State.count(new BiColorGameOfLifeState(StateType.ALIVE_BLUE), neighbours);
+        int liveCount = redCount + blueCount;
+
+        if (currentState == StateType.DEAD && liveCount == 3) {
+            return new BiColorGameOfLifeState(redCount > blueCount ? StateType.ALIVE_RED : StateType.ALIVE_BLUE);
+        } else if (currentState != StateType.DEAD && (liveCount == 2 || liveCount == 3)) {
+            return this;
+        } else {
+            return new BiColorGameOfLifeState(StateType.DEAD);
+        }
+    }
+}
+

src/main/java/model/automata/BrianBrainAutomaton.java

+package model.automata;
+import model.CellularAutomaton;
+
+import java.util.Random;
+
+public class BrianBrainAutomaton implements CellularAutomaton<BrianBrainState> {
+    private final int rows;
+    private final int columns;
+
+    public BrianBrainAutomaton(int rows, int columns) {
+        this.rows = rows;
+        this.columns = columns;
+    }
+
+    @Override
+    public int numberOfColumns() {
+        return columns;
+    }
+
+    @Override
+    public int numberOfRows() {
+        return rows;
+    }
+
+    @Override
+    public BrianBrainState defaultState() {
+        return new BrianBrainState(BrianBrainState.StateType.DEAD);
+    }
+
+    @Override
+    public BrianBrainState randomState(Random generator) {
+        return generator.nextDouble() < 0.5
+                ? new BrianBrainState(BrianBrainState.StateType.DEAD)
+                : new BrianBrainState(BrianBrainState.StateType.READY_TO_FIRE);
+    }
+}
+

src/main/java/model/automata/BrianBrainState.java

+package model.automata;
+
+import javafx.scene.paint.Color;
+import model.State;
+
+import java.util.List;
+
+public class BrianBrainState implements State<BrianBrainState> {
+    enum StateType { DEAD,
+        FIRE,
+        READY_TO_FIRE }
+
+    private final StateType currentState;
+
+    public BrianBrainState(StateType state) {
+        this.currentState = state;
+    }
+
+    @Override
+    public Color getColor() {
+        return switch (currentState) {
+            case DEAD -> Color.WHITE;
+            case FIRE -> Color.RED;
+            case READY_TO_FIRE -> Color.YELLOW;
+        };
+    }
+    @Override
+    public BrianBrainState next() {
+        return new BrianBrainState(currentState == StateType.FIRE ? StateType.DEAD : StateType.FIRE);
+    }
+    @Override
+    public BrianBrainState update(List<BrianBrainState> neighbours) {
+        int fireCount = (int) neighbours.stream().filter(n -> n.currentState == StateType.FIRE).count();
+
+        if (currentState == StateType.READY_TO_FIRE && fireCount > 0) {
+            return new BrianBrainState(StateType.FIRE);
+        } else if (currentState == StateType.FIRE) {
+            return new BrianBrainState(StateType.DEAD);
+        } else {
+            return this;
+        }
+    }
+}
+