Skip to content
Snippets Groups Projects
Commit 1b6da429 authored by MSAYIF Bassem's avatar MSAYIF Bassem
Browse files

Deleted TP 3 folder, moved to https://etulab.univ-amu.fr/l19013671/tp3

parent 69ad4c9a
No related branches found
No related tags found
No related merge requests found
/**
* {@link Cell} instances represent the cells of <i>The Game of Life</i>.
*/
public class Cell {
private boolean isAlive;
public Cell(){
this.isAlive = false;
}
/**
* Determines whether this {@link Cell} is alive or not.
*
* @return {@code true} if this {@link Cell} is alive and {@code false} otherwise
*/
public boolean isAlive() {
return this.isAlive;
}
/**
* Determines whether this {@link Cell} is dead or not.
*
* @return {@code true} if this {@link Cell} is dead and {@code false} otherwise
*/
public boolean isDead() {
return !this.isAlive;
}
/**
* Sets the state of this {@link Cell} to alive.
*
* @param cellState the new state of this {@link Cell}
*/
public void setAlive() {
this.isAlive = true;
}
/**
* Sets the state of this {@link Cell} to dead.
*
* @param cellState the new state of this {@link Cell}
*/
public void setDead() {
this.isAlive = false;
}
/**
* Change the state of this {@link Cell} from ALIVE to DEAD or from DEAD to ALIVE.
*/
public void toggleState() {
if(this.isAlive)
this.isAlive = false;
else
this.isAlive = true;
}
public boolean isAliveInNextState(int numberOfAliveNeighbours) {
if(isAlive()){
if (numberOfAliveNeighbours == 2 || numberOfAliveNeighbours == 3)
return true;
else
return false;
}
else{
if (numberOfAliveNeighbours == 3)
return true;
else
return false;
}
}
}
import java.util.Random;
/**
* {@link GameOfLife} instances run <i>The Game of Life</i>.
*/
public class GameOfLife {
private final Random random = new Random();
private final Grid grid;
private int generationNumber;
/**
* Creates a new {@code GameOfLife} instance given the underlying {@link Grid}.
*
* @param grid the underlying {@link Grid}
* @throws NullPointerException if {@code grid} is {@code null}
*/
public GameOfLife(Grid grid) {
// this.grid = requireNonNull(grid, "grid is null");
this.grid = grid;
grid.randomGeneration(random);
}
/**
* Transitions into the next generationNumber.
*/
public void next() {
grid.nextGeneration();
generationNumber++;
}
/**
* Returns the current generationNumber.
*
* @return the current generationNumber
*/
private int getGenerationNumber() {
return generationNumber;
}
/**
* Returns the {@link Grid}.
*
* @return the {@link Grid}
*/
public Grid getGrid() {
return grid;
}
/**
* Plays the game.
*/
public void play(int maxGenerations) {
for(int generation =0; generation < maxGenerations; generation++){
this.next();
System.out.println("generation : " + generation);
}
}
/**
* Pauses the game.
*/
public void pause() {
// timeline.pause();
}
/**
* Clears the current game.
*/
public void clear() {
pause();
grid.clear();
generationNumber = 0;
}
/**
* Clears the current game and randomly generates a new one.
*/
public void reset() {
clear();
grid.randomGeneration(random);
}
}
import java.awt.*;
import java.awt.Graphics;
import javax.swing.*;
public class GameOfLifeGUI extends JFrame {
private int squareSize = 7;
private int numberOfRows;
private int numberOfColumns;
private JLabel[][] labelGrid;
private GridLayout gridLayout;
private JPanel gridPanel;
private JFrame frame;
public GameOfLifeGUI(Grid g) {
this.numberOfRows = g.getNumberOfRows();
this.numberOfColumns = g.getNumberOfColumns();
gridLayout = new GridLayout(numberOfRows, numberOfColumns);
gridPanel = new JPanel(gridLayout);
labelGrid = new JLabel[numberOfRows][numberOfColumns];
for (int x = 0; x < numberOfColumns; x++)
for (int y = 0; y < numberOfRows; y++){
labelGrid[x][y] = new JLabel("*");
JLabel label;
if(g.getCell(x,y).isAlive())
labelGrid[x][y].setForeground(Color.red);
else
labelGrid[x][y].setForeground(Color.white);
gridPanel.add(labelGrid[x][y]);
}
frame = new JFrame("Game of Life");
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.setContentPane(gridPanel);
frame.setSize(squareSize * numberOfRows, squareSize * numberOfColumns);
frame.setLocationByPlatform(true);
frame.setVisible(true);
}
public void update(Grid g){
for (int x = 0; x < numberOfColumns; x++)
for (int y = 0; y < numberOfRows; y++){
JLabel label = labelGrid[x][y];
if(g.getCell(x,y).isAlive())
label.setForeground(Color.red);
else
label.setForeground(Color.white);
}
}
}
import java.util.*;
/**
* {@code Grid} instances represent the grid in <i>The Game of Life</i>.
*/
public class Grid implements Iterable<Cell> {
private final int numberOfRows;
private final int numberOfColumns;
private final Cell[][] cells;
/**
* Creates a new {@code Grid} instance given the number of rows and columns.
*
* @param numberOfRows the number of rows
* @param numberOfColumns the number of columns
* @throws IllegalArgumentException if {@code numberOfRows} or {@code numberOfColumns} are
* less than or equal to 0
*/
public Grid(int numberOfRows, int numberOfColumns) {
this.numberOfRows = numberOfRows;
this.numberOfColumns = numberOfColumns;
this.cells = createCells();
}
@Override
public Iterator<Cell> iterator() {
return new GridIterator(this);
}
private Cell[][] createCells() {
Cell[][] cells = new Cell[getNumberOfRows()][getNumberOfColumns()];
for (int rowIndex = 0; rowIndex < getNumberOfRows(); rowIndex++) {
for (int columnIndex = 0; columnIndex < getNumberOfColumns(); columnIndex++) {
cells[rowIndex][columnIndex] = new Cell();
}
}
return cells;
}
/**
* Returns the {@link Cell} at the given index.
*
* <p>Note that the index is wrapped around so that a {@link Cell} is always returned.
*
* @param rowIndex the row index of the {@link Cell}
* @param columnIndex the column index of the {@link Cell}
* @return the {@link Cell} at the given row and column index
*/
public Cell getCell(int rowIndex, int columnIndex) {
return cells[getWrappedRowIndex(rowIndex)][getWrappedColumnIndex(columnIndex)];
}
private int getWrappedRowIndex(int rowIndex) {
return (rowIndex + getNumberOfRows()) % getNumberOfRows();
}
private int getWrappedColumnIndex(int columnIndex) {
return (columnIndex + getNumberOfColumns()) % getNumberOfColumns();
}
/**
* Returns the number of rows in this {@code Grid}.
*
* @return the number of rows in this {@code Grid}
*/
public int getNumberOfRows() {
return numberOfRows;
}
/**
* Returns the number of columns in this {@code Grid}.
*
* @return the number of columns in this {@code Grid}
*/
public int getNumberOfColumns() {
return numberOfColumns;
}
/**
* Transitions all {@link Cell}s in this {@code Grid} to the next generation.
*
* <p>The following rules are applied:
* <ul>
* <li>Any live {@link Cell} with fewer than two live neighbours dies, i.e. underpopulation.</li>
* <li>Any live {@link Cell} with two or three live neighbours lives on to the next
* generation.</li>
* <li>Any live {@link Cell} with more than three live neighbours dies, i.e. overpopulation.</li>
* <li>Any dead {@link Cell} with exactly three live neighbours becomes a live cell, i.e.
* reproduction.</li>
* </ul>
*/
void nextGeneration() {
goToNextState(calculateNextStates());
}
private boolean[][] calculateNextStates() {
boolean[][] array = new boolean[getNumberOfRows()][getNumberOfColumns()];
for (int collum = 0; collum < getNumberOfColumns(); collum++) {
for (int row = 0; row < getNumberOfRows(); row++) {
array[row][collum] = calculateNextState(row,collum,getCell(row,collum));
}
}
return array;
}
private boolean calculateNextState(int rowIndex, int columnIndex, Cell cell) {
return cell.isAliveInNextState(countAliveNeighbours(rowIndex,columnIndex));
}
private int countAliveNeighbours(int rowIndex, int columnIndex) {
int numCellAlive = 0;
for (Cell cell : getNeighbours(rowIndex,columnIndex)){
if(cell.isAlive()){
numCellAlive ++;
}
}
return numCellAlive;
}
private List<Cell> getNeighbours(int rowIndex, int columnIndex) {
List<Cell> neighboursList = new ArrayList<>();
neighboursList.add(getCell(rowIndex+1,columnIndex));
neighboursList.add(getCell(rowIndex-1,columnIndex));
neighboursList.add(getCell(rowIndex,columnIndex+1));
neighboursList.add(getCell(rowIndex,columnIndex-1));
neighboursList.add(getCell(rowIndex+1,columnIndex+1));
neighboursList.add(getCell(rowIndex-1,columnIndex-1));
neighboursList.add(getCell(rowIndex-1,columnIndex+1));
neighboursList.add(getCell(rowIndex+1,columnIndex-1));
return neighboursList;
}
private void goToNextState(boolean[][] nextState) {
boolean[][] array = nextState;
for (int collum = 0; collum < getNumberOfColumns(); collum++) {
for (int row = 0; row < getNumberOfRows(); row++) {
if(array[row][collum]){
cells[row][collum].setAlive();
}
else cells[row][collum].setDead();
}
}
}
/**
* Sets all {@link Cell}s in this {@code Grid} as dead.
*/
void clear() {
for (int i = 0; i < this.numberOfRows; i++) {
for (int j = 0; j < this.numberOfColumns; j++) {
cells[i][j].setDead();
}
}
}
/**
* Goes through each {@link Cell} in this {@code Grid} and randomly sets it as alive or dead.
*
* @param random {@link Random} instance used to decide if each {@link Cell} is alive or dead
* @throws NullPointerException if {@code random} is {@code null}
*/
void randomGeneration(Random random) {
for (int i = 0; i < getNumberOfRows(); i++) {
for (int j = 0; j < getNumberOfColumns(); j++) {
if(random.nextBoolean()){
cells[i][j].setAlive();
}
}
}
}
}
import java.util.Iterator;
/**
* {@link GridIterator} instances are used to iterate over the cells of a grid.
*/
public class GridIterator implements Iterator<Cell> {
private int rowIndex;
private int columnIndex;
private Grid grid;
GridIterator(Grid grid) {
this.rowIndex = 0;
this.columnIndex = 0;
this.grid = grid;
}
@Override
public boolean hasNext() {
return columnIndex < grid.getNumberOfColumns() && rowIndex < grid.getNumberOfRows();
}
@Override
public Cell next() {
final Cell result = grid.getCell(rowIndex, columnIndex);
columnIndex = (columnIndex +1) % grid.getNumberOfColumns();
if(columnIndex == 0){
rowIndex++;
}
return result;
}
}
import java.io.*;
import java.awt.*;
import javax.swing.*;
public class Main{
public static void main(String args[]) throws IOException {
int NUMBER_OF_ROWS = 64;
int NUMBER_OF_COLUMNS = 64;
GameOfLife gameOfLife = new GameOfLife(new Grid(NUMBER_OF_ROWS, NUMBER_OF_COLUMNS));
GameOfLifeGUI gui = new GameOfLifeGUI(gameOfLife.getGrid());
for(int generation =0; generation < 1000; generation++){
try {
Thread.sleep(100);
} catch (InterruptedException ie) {
}
gameOfLife.next();
gui.update(gameOfLife.getGrid());
}
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment