titouan.berne
/
OOP_B03_Project
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Source importation

This commit is contained in:
titou 2024-05-02 10:46:14 +02:00
parent 7c7f502fb2
commit 263dc88de9
6 changed files with 934 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/Main.java Normal file
View File

@ -0,0 +1,12 @@
import windowInterface.MyInterface;
public class Main {
public static void main(String[] args) {
MyInterface mjf = new MyInterface();
mjf.setVisible(true);
}
}

40
src/backend/Agent.java Normal file
View File

@ -0,0 +1,40 @@
package backend;
import java.awt.Color;
import java.util.ArrayList;
public abstract class Agent {
protected int x;
protected int y;
protected Color color;
protected Agent(int x, int y, Color color) {
this.x = x;
this.y = y;
this.color = color;
}
public Color getDisplayColor() {
return color;
}
public int getX() {
return x;
}
public int getY() {
return y;
}
public boolean isInArea(int x, int y, int radius) {
int diffX = this.x-x;
int diffY = this.y-y;
int dist = (int) Math.floor(Math.sqrt(diffX*diffX+diffY*diffY));
return dist<radius;
}
// Does whatever the agent does during a step
// then returns a boolean
// if false, agent dies at end of turn
// see step function in Simulator
public abstract boolean liveTurn(ArrayList<Agent> neighbors, Simulator world);
}

59
src/backend/Sheep.java Normal file
View File

@ -0,0 +1,59 @@
package backend;
import java.awt.Color;
import java.util.ArrayList;
import java.util.Random;
// example of basic animal.
// do not hesitate to make it more complex
// and DO add at least another species that interact with it
// for example wolves that eat Sheep
public class Sheep extends Agent {
int hunger;
Random rand;
Sheep(int x,int y){
//first we call the constructor of the superClass(Animal)
//with the values we want.
// here we decide that a Sheep is initially white using this constructor
super(x,y,Color.white);
// we give our sheep a hunger value of zero at birth
hunger = 0;
//we initialize the random number generator we will use to move randomly
rand = new Random();
}
/**
* action of the animal
* it can interact with the cells or with other animals
* as you wish
*/
public boolean liveTurn(ArrayList<Agent> neighbors, Simulator world) {
if(world.getCell(x, y)==1) {
world.setCell(x, y, 0);
} else {
hunger++;
}
this.moveRandom();
return hunger>10;
}
private void moveRandom() {
int direction = rand.nextInt(4);
if(direction == 0) {
x+=1;
}
if(direction == 1) {
y+=1;
}
if(direction == 2) {
x-=1;
}
if(direction == 3) {
y-=1;
}
}
}

332
src/backend/Simulator.java Normal file
View File

@ -0,0 +1,332 @@
package backend;
import java.util.ArrayList;
import windowInterface.MyInterface;
public class Simulator extends Thread {
private MyInterface mjf;
private final int COL_NUM = 100;
private final int LINE_NUM = 100;
private final int LIFE_TYPE_NUM = 4;
//Conway Radius : 1
private final int LIFE_AREA_RADIUS = 1;
//Animal Neighborhood Radius : 5
private final int ANIMAL_AREA_RADIUS = 2;
private ArrayList<Integer> fieldSurviveValues;
private ArrayList<Integer> fieldBirthValues;
private ArrayList<Agent> agents;
private boolean stopFlag;
private boolean pauseFlag;
private boolean loopingBorder;
private boolean clickActionFlag;
private int loopDelay = 150;
//TODO : add missing attribute(s)
public Simulator(MyInterface mjfParam) {
mjf = mjfParam;
stopFlag=false;
pauseFlag=false;
loopingBorder=false;
clickActionFlag=false;
agents = new ArrayList<Agent>();
fieldBirthValues = new ArrayList<Integer>();
fieldSurviveValues = new ArrayList<Integer>();
//TODO : add missing attribute initialization
//Default rule : Survive always, birth never
for(int i =0; i<9; i++) {
fieldSurviveValues.add(i);
}
}
public int getWidth() {
//TODO : replace with proper return
return 0;
}
public int getHeight() {
//TODO : replace with proper return
return 0;
}
//Should probably stay as is
public void run() {
int stepCount=0;
while(!stopFlag) {
stepCount++;
makeStep();
mjf.update(stepCount);
try {
Thread.sleep(loopDelay);
} catch (InterruptedException e) {
e.printStackTrace();
}
while(pauseFlag && !stopFlag) {
try {
Thread.sleep(loopDelay);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* method called at each step of the simulation
* makes all the actions to go from one step to the other
*/
public void makeStep() {
// agent behaviors first
// only modify if sure of what you do
// to modify agent behavior, see liveTurn method
// in agent classes
for(Agent agent : agents) {
ArrayList<Agent> neighbors =
this.getNeighboringAnimals(
agent.getX(),
agent.getY(),
ANIMAL_AREA_RADIUS);
if(!agent.liveTurn(
neighbors,
this)) {
agents.remove(agent);
}
}
//then evolution of the field
// TODO : apply game rule to all cells of the field
/* you should distribute this action in methods/classes
* don't write everything here !
*
* the idea is first to get the surrounding values
* then count how many are alive
* then check if that number is in the lists of rules
* if the cell is alive
* and the count is in the survive list,
* then the cell stays alive
* if the cell is not alive
* and the count is in the birth list,
* then the cell becomes alive
*/
}
/*
* leave this as is
*/
public void stopSimu() {
stopFlag=true;
}
/*
* method called when clicking pause button
*/
public void togglePause() {
// TODO : actually toggle the corresponding flag
}
/**
* method called when clicking on a cell in the interface
*/
public void clickCell(int x, int y) {
//TODO : complete method
}
/**
* get cell value in simulated world
* @param x coordinate of cell
* @param y coordinate of cell
* @return value of cell
*/
public int getCell(int x, int y) {
//TODO : complete method with proper return
return 0;
}
/**
*
* @return list of Animals in simulated world
*/
public ArrayList<Agent> getAnimals(){
return agents;
}
/**
* selects Animals in a circular area of simulated world
* @param x center
* @param y center
* @param radius
* @return list of agents in area
*/
public ArrayList<Agent> getNeighboringAnimals(int x, int y, int radius){
ArrayList<Agent> inArea = new ArrayList<Agent>();
for(int i=0;i<agents.size();i++) {
Agent agent = agents.get(i);
if(agent.isInArea(x,y,radius)) {
inArea.add(agent);
}
}
return inArea;
}
/**
* set value of cell
* @param x coord of cell
* @param y coord of cell
* @param val to set in cell
*/
public void setCell(int x, int y, int val) {
//TODO : complete method
}
/**
*
* @return lines of file representing
* the simulated world in its present state
*/
public ArrayList<String> getSaveState() {
//TODO : complete method with proper return
return null;
}
/**
*
* @param lines of file representing saved world state
*/
public void loadSaveState(ArrayList<String> lines) {
/*
* First some checks that the file is usable
* We call early returns in conditions like this
* "Guard clauses", as they guard the method
* against unwanted inputs
*/
if(lines.size()<=0) {
return;
}
String firstLine = lines.get(0);
String[] firstLineElements = firstLine.split(";");
if(firstLineElements.length<=0) {
return;
}
/*
* now we fill in the world
* with the content of the file
*/
for(int y =0; y<lines.size();y++) {
String line = lines.get(y);
String[] lineElements = line.split(";");
for(int x=0; x<lineElements.length;x++) {
String elem = lineElements[x];
int value = Integer.parseInt(elem);
setCell(x, y, value);
}
}
}
/**
* called by button, with slider providing the argument
* makes a new world state with random cell states
* @param chanceOfLife the chance for each cell
* to be alive in new state
*/
public void generateRandom(float chanceOfLife) {
//TODO : complete method
/*
* Advice :
* as you should probably have a separate class
* representing the field of cells...
* maybe just make a constructor in there
* and use it here
*/
}
public boolean isLoopingBorder() {
//TODO : complete method with proper return
return false;
}
public void toggleLoopingBorder() {
//TODO : complete method
}
public void setLoopDelay(int delay) {
//TODO : complete method
}
public void toggleClickAction() {
//TODO : complete method
}
/**
* prepare the content of a file saving present ruleSet
* as you might want to save a state,
* initialy written in this class constructor
* as a file for future use
* @return File content as an ArrayList of Lines (String)
* @see loadRule for inverse process
*/
public ArrayList<String> getRule() {
//TODO : complete method with proper return
return null;
}
public void loadRule(ArrayList<String> lines) {
if(lines.size()<=0) {
System.out.println("empty rule file");
return;
}
//TODO : remove previous rule (=emptying lists)
String surviveLine = lines.get(0);
String birthLine = lines.get(1);
String[] surviveElements = surviveLine.split(";");
for(int x=0; x<surviveElements.length;x++) {
String elem = surviveElements[x];
int value = Integer.parseInt(elem);
//TODO : add value to possible survive values
}
String[] birthElements = birthLine.split(";");
for(int x=0; x<birthElements.length;x++) {
String elem = birthElements[x];
int value = Integer.parseInt(elem);
//TODO : add value to possible birth values
}
}
public ArrayList<String> getAgentsSave() {
//TODO : Same idea as the other save method, but for agents
return null;
}
public void loadAgents(ArrayList<String> stringArray) {
//TODO : Same idea as other load methods, but for agent list
}
/**
* used by label in interface to show the active click action
* @return String representation of click action
*/
public String clickActionName() {
// TODO : initially return "sheep" or "cell"
// depending on clickActionFlag
return "";
}
}

94
src/windowInterface/JPanelDraw.java Normal file
View File

@ -0,0 +1,94 @@
package windowInterface;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import javax.swing.JPanel;
import backend.Agent;
import backend.Simulator;
public class JPanelDraw extends JPanel {
private static final long serialVersionUID = 1L;
private Simulator mySimu;
private MyInterface interfaceGlobal;
public JPanelDraw(MyInterface itf) {
super();
mySimu = null;
interfaceGlobal = itf;
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me) {
// System.out.println(me);
if(mySimu == null) {
interfaceGlobal.instantiateSimu();
}
int x = (me.getX()*mySimu.getWidth())/getWidth();
int y = (me.getY()*mySimu.getHeight())/getHeight();
mySimu.clickCell(x,y);
repaint();
}
});
}
public void setSimu(Simulator simu) {
mySimu = simu;
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
this.setBackground(Color.black);
if (mySimu != null) {
// Draw Interface from state of simulator
float cellWidth = (float)this.getWidth()/(float)mySimu.getWidth();
float cellHeight = (float)this.getHeight()/(float)mySimu.getHeight();
g.setColor(Color.gray);
for(int x=0; x<mySimu.getWidth();x++) {
int graphX = Math.round(x*cellWidth);
g.drawLine(graphX, 0, graphX, this.getHeight());
}
for (int y=0; y<mySimu.getHeight(); y++) {
int graphY = Math.round(y*cellHeight);
g.drawLine(0, graphY, this.getWidth(), graphY);
}
for(int x=0; x<mySimu.getWidth();x++) {
for (int y=0; y<mySimu.getHeight(); y++) {
int cellContent = mySimu.getCell(x,y);
if(cellContent == 0) {
continue;
}
if(cellContent == 1) {
g.setColor(Color.green);
}
if(cellContent == 2) {
g.setColor(Color.yellow);
}
if(cellContent == 3) {
g.setColor(Color.cyan);
}
g.fillRect(
(int) Math.round(x*cellWidth),
(int) Math.round(y*cellHeight),
(int) Math.round(cellWidth),
(int) Math.round(cellHeight)
);
}
}
for (Agent animal:mySimu.getAnimals()){
g.setColor(animal.getDisplayColor());
g.fillOval((int)Math.round(animal.getX()*cellWidth),
(int)Math.round(animal.getY()*cellHeight),
(int)Math.round(cellWidth/2),
(int)Math.round(cellHeight/2));
}
}
}
}

397
src/windowInterface/MyInterface.java Normal file
View File

@ -0,0 +1,397 @@
package windowInterface;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.SwingConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import backend.Simulator;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.awt.event.ActionEvent;
public class MyInterface extends JFrame {
private static final long serialVersionUID = -6840815447618468846L;
private JPanel contentPane;
private JLabel stepLabel;
private JLabel borderLabel;
private JLabel speedLabel;
private JPanelDraw panelDraw;
private Simulator mySimu=null;
private JSlider randSlider;
private JSlider speedSlider;
private JLabel clickLabel;
/**
* Create the frame.
*/
public MyInterface() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(10, 10, 700, 600);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
contentPane.setLayout(new BorderLayout(0, 0));
setContentPane(contentPane);
JPanel panelTop = new JPanel();
contentPane.add(panelTop, BorderLayout.NORTH);
JPanel panelRight = new JPanel();
panelRight.setLayout(new GridLayout(12,1));
contentPane.add(panelRight, BorderLayout.EAST);
JButton btnGo = new JButton("Start/Pause");
btnGo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicButtonGo();
}
});
panelTop.add(btnGo);
JButton btnClickAct = new JButton("Toggle Click");
btnClickAct.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicButtonToggleClickAction();
}
});
panelTop.add(btnClickAct);
stepLabel = new JLabel("Step : X");
panelTop.add(stepLabel);
speedLabel = new JLabel("speed slider : ");
panelTop.add(speedLabel);
speedSlider = new JSlider();
speedSlider.setValue(3);
speedSlider.setMinimum(0);
speedSlider.setMaximum(10);
speedSlider.setOrientation(SwingConstants.HORIZONTAL);
speedSlider.setPreferredSize(new Dimension(100,30));
speedSlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent arg0) {
changeSpeed();
}
});
panelTop.add(speedSlider);
// JButton btnSpeed = new JButton("Set Speed");
// btnSpeed.addActionListener(new ActionListener() {
// public void actionPerformed(ActionEvent e) {
// clicButtonSpeed();
// }
// });
// panelTop.add(btnSpeed);
JButton btnLoad = new JButton("Load World");
btnLoad.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicLoadFileButton();
}
});
panelRight.add(btnLoad);
JButton btnSave = new JButton("Save World");
btnSave.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicSaveToFileButton();
}
});
panelRight.add(btnSave);
JButton btnLoadRule = new JButton("Load Rule");
btnLoadRule.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicLoadRuleFileButton();
}
});
panelRight.add(btnLoadRule);
JButton btnSaveRule = new JButton("Save Rule");
btnSaveRule.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicSaveRuleToFileButton();
}
});
panelRight.add(btnSaveRule);
JButton btnLoadAgents = new JButton("Load Agents");
btnLoadAgents.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicLoadAgentsFileButton();;
}
});
panelRight.add(btnLoadAgents);
JButton btnSaveAgents = new JButton("Save Agents");
btnSaveAgents.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicSaveAgentsToFileButton();
}
});
panelRight.add(btnSaveAgents);
JButton btnRandGen = new JButton("Random Field");
btnRandGen.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
generateRandomBoard();
}
});
panelRight.add(btnRandGen);
JLabel randLabel = new JLabel("random density slider :");
panelRight.add(randLabel);
randSlider = new JSlider();
randSlider.setValue(50);
randSlider.setMinimum(0);
randSlider.setMaximum(100);
randSlider.setPreferredSize(new Dimension(30,200));
panelRight.add(randSlider);
JButton btnBorder = new JButton("Toggle Border");
btnBorder.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
clicButtonBorder();
}
});
panelRight.add(btnBorder);
panelDraw = new JPanelDraw(this);
contentPane.add(panelDraw, BorderLayout.CENTER);
instantiateSimu();
borderLabel = new JLabel("border : X");
panelRight.add(borderLabel);
borderLabel.setText("border : " +
(mySimu.isLoopingBorder()?"loop":"closed"));
clickLabel = new JLabel("click : X");
panelRight.add(clickLabel);
clickLabel.setText("click : " + mySimu.clickActionName());
}
public void setStepBanner(String s) {
stepLabel.setText(s);
}
public void setBorderBanner(String s) {
borderLabel.setText(s);
}
public void setClickBanner(String s) {
clickLabel.setText(s);
}
public JPanelDraw getPanelDessin() {
return panelDraw;
}
public void instantiateSimu() {
if(mySimu==null) {
mySimu = new Simulator(this);
panelDraw.setSimu(mySimu);
}
}
public void clicButtonGo() {
this.instantiateSimu();
if(!mySimu.isAlive()) {
mySimu.start();
} else {
mySimu.togglePause();
}
}
public void clicButtonToggleClickAction() {
if(mySimu != null) {
mySimu.toggleClickAction();
clickLabel.setText("click : " + mySimu.clickActionName());
}
}
public void clicButtonBorder() {
if(mySimu != null) {
mySimu.toggleLoopingBorder();
borderLabel.setText("border : " +
(mySimu.isLoopingBorder()?"loop":"closed"));
}
}
public void generateRandomBoard() {
this.instantiateSimu();
float chanceOfLife = ((float)randSlider.getValue())/((float)randSlider.getMaximum());
mySimu.generateRandom(chanceOfLife);
panelDraw.repaint();
}
public void changeSpeed() {
if(mySimu != null) {
int delay = (int)Math.pow(2, 10-speedSlider.getValue());
mySimu.setLoopDelay(delay);
} else {
speedSlider.setValue(3);
}
}
public void clicLoadFileButton() {
Simulator loadedSim = new Simulator(this);
String fileName=SelectFile();
ArrayList<String> stringArray = new ArrayList<String>();
if (fileName.length()>0) {
try {
BufferedReader fileContent = new BufferedReader(new FileReader(fileName));
String line = fileContent.readLine();
while (line != null) {
stringArray.add(line);
line = fileContent.readLine();
}
fileContent.close();
} catch (Exception e) {
e.printStackTrace();
}
if(mySimu != null) {
mySimu.stopSimu();
this.eraseLabels();
}
loadedSim.loadSaveState(stringArray);
mySimu = loadedSim;
panelDraw.setSimu(mySimu);
this.repaint();
}
}
public void clicLoadRuleFileButton() {
String fileName=SelectFile();
ArrayList<String> stringArray = new ArrayList<String>();
if (fileName.length()>0) {
try {
BufferedReader fileContent = new BufferedReader(new FileReader(fileName));
String line = fileContent.readLine();
while (line != null) {
stringArray.add(line);
line = fileContent.readLine();
}
fileContent.close();
} catch (Exception e) {
e.printStackTrace();
}
mySimu.loadRule(stringArray);
this.repaint();
}
}
public void clicLoadAgentsFileButton() {
String fileName=SelectFile();
ArrayList<String> stringArray = new ArrayList<String>();
if (fileName.length()>0) {
try {
BufferedReader fileContent = new BufferedReader(new FileReader(fileName));
String line = fileContent.readLine();
while (line != null) {
stringArray.add(line);
line = fileContent.readLine();
}
fileContent.close();
} catch (Exception e) {
e.printStackTrace();
}
mySimu.loadAgents(stringArray);
this.repaint();
}
}
public void clicSaveToFileButton() {
String fileName=SelectFile();
if (fileName.length()>0) {
ArrayList<String> content = mySimu.getSaveState();
String[] strArr = Arrays.copyOf(content.toArray(), content.toArray().length, String[].class);
writeFile(fileName, strArr);
}
}
public void clicSaveRuleToFileButton() {
String fileName=SelectFile();
if (fileName.length()>0) {
ArrayList<String> content = mySimu.getRule();
String[] strArr = Arrays.copyOf(content.toArray(), content.toArray().length, String[].class);
writeFile(fileName, strArr);
}
}
public void clicSaveAgentsToFileButton() {
String fileName=SelectFile();
if (fileName.length()>0) {
ArrayList<String> content = mySimu.getAgentsSave();
String[] strArr = Arrays.copyOf(content.toArray(), content.toArray().length, String[].class);
writeFile(fileName, strArr);
}
}
public String SelectFile() {
String s;
JFileChooser chooser = new JFileChooser();
chooser.setCurrentDirectory(new java.io.File("."));
chooser.setDialogTitle("Choose a file");
chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
chooser.setAcceptAllFileFilterUsed(true);
if (chooser.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
s=chooser.getSelectedFile().toString();
} else {
System.out.println("No Selection ");
s="";
}
return s;
}
public void writeFile(String fileName, String[] content) {
FileWriter csvWriter;
try {
csvWriter = new FileWriter(fileName);
for (String row : content) {
csvWriter.append(row);
csvWriter.append("\n");
}
csvWriter.flush();
csvWriter.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void update (int stepCount) {
this.setStepBanner("Step : "+ stepCount);
this.repaint();
}
public void eraseLabels() {
this.setStepBanner("Step : X");
this.setBorderBanner("border : X");
this.setClickBanner("click : X");
speedSlider.setValue(3);
}
}