initial

.gitignore

@@ -0,0 +1,3 @@
+out/*
+.idea/*
+*.iml

src/sample/Controller.java

@@ -0,0 +1,4 @@
+package sample;
+
+public class Controller {
+}

src/sample/Main.java

@@ -0,0 +1,23 @@
+package sample;
+
+import javafx.application.Application;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Parent;
+import javafx.scene.Scene;
+import javafx.stage.Stage;
+
+public class Main extends Application {
+
+    @Override
+    public void start(Stage primaryStage) throws Exception{
+        Parent root = FXMLLoader.load(getClass().getResource("sample.fxml"));
+        primaryStage.setTitle("Hello World");
+        primaryStage.setScene(new Scene(root, 300, 275));
+        primaryStage.show();
+    }
+
+
+    public static void main(String[] args) {
+        launch(args);
+    }
+}

src/sample/sample.fxml

@@ -0,0 +1,8 @@
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.layout.GridPane?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<GridPane fx:controller="sample.Controller"
+          xmlns:fx="http://javafx.com/fxml" alignment="center" hgap="10" vgap="10">
+</GridPane>

src/simulation/Animal.java

@@ -0,0 +1,85 @@
+package simulation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Animal{
+    private final int birthDay;
+    private int deathDay;
+    private final Genome genome;
+    private Simulation simulation;
+
+    private Location location;
+    private Direction direction;
+    private int energy;
+
+
+    private List<AnimalStateAfterDay> stateAfterEachDay = new ArrayList<>();
+
+    Animal(Animal parent1, Animal parent2, int energy){
+        this.simulation = parent1.simulation;
+        this.genome = new Genome(parent1.getGenome(), parent2.getGenome());
+        this.energy = energy;
+        this.birthDay = simulation.getCurrentDay();
+    }
+
+    public void kill() throws AnimalStateException {
+        if (!this.isAlive())
+            throw new AnimalStateException("Trying to kill a dead animal: " + this.toString());
+        this.energy = 0;
+        this.deathDay = simulation.getCurrentDay();
+    }
+    public Direction shift() {
+        return direction = direction.shiftedBy(genome.pickRandomGene());
+    }
+
+    public Location move() throws AnimalStateException {
+        if (!this.isAlive())
+            throw new AnimalStateException("Trying to move a dead animal: " + this.toString());
+        if (this.energy < simulation.getParams().getMoveEnergy())
+            this.kill();
+        this.energy -= simulation.getParams().getMoveEnergy();
+        int boardWidth = simulation.getParams().getWidth();
+        int boardHeight = simulation.getParams().getHeight();
+        int newX = (location.getX() + direction.getX() + boardWidth) % boardWidth;
+        int newY = (location.getY() + direction.getY() + boardHeight) % boardHeight;
+        return location = new Location(newX,newY);
+    }
+
+    private void saveStateAfterDay(){
+
+    }
+
+
+    public int getBirthDay() {
+        return birthDay;
+    }
+
+    public int getDeathDay() {
+        return deathDay;
+    }
+
+    public Genome getGenome() {
+        return genome;
+    }
+
+    public Location getLocation() {
+        return location;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public boolean isAlive() {
+        return energy > 0;
+    }
+
+    public int getEnergy() {
+        return energy;
+    }
+
+    public List<AnimalStateAfterDay> getStateAfterEachDay() {
+        return stateAfterEachDay;
+    }
+}

src/simulation/AnimalStateAfterDay.java

@@ -0,0 +1,17 @@
+package simulation;
+
+import java.util.ArrayList;
+
+public class AnimalStateAfterDay {
+    public final Location location;
+    public final Direction direction;
+    public final int energy;
+    public final ArrayList<Animal> childrenBornOnThisDay;
+
+    public AnimalStateAfterDay(Location location, Direction direction, int energy, ArrayList<Animal> childrenBornOnThisDay) {
+        this.location = location;
+        this.direction = direction;
+        this.energy = energy;
+        this.childrenBornOnThisDay = childrenBornOnThisDay;
+    }
+}

src/simulation/AnimalStateException.java

@@ -0,0 +1,7 @@
+package simulation;
+
+public class AnimalStateException extends SimulationErrorException {
+    public AnimalStateException(String errorMessage) {
+        super(errorMessage);
+    }
+}

src/simulation/Board.java

@@ -0,0 +1,9 @@
+package simulation;
+
+import java.util.*;
+
+public class Board {
+    private AbstractSet<Location> plantedSpots = new TreeSet<>();
+    private AbstractMap<Location, List<Animal>> animalLocations = new TreeMap<>();
+    private AbstractMap<Genome,Integer> dominantGenomes = new TreeMap<>();
+}

src/simulation/BoardParams.java

@@ -0,0 +1,43 @@
+package simulation;
+
+public class BoardParams {
+    private final int width;
+    private final int height;
+    private final double jungleRatio;
+    private final double moveEnergy;
+    private final double plantEnergy;
+    private final int initialAnimalsNum;
+
+    public BoardParams(int width, int height, double jungleRatio, double moveEnergy, double plantEnergy, int initialAnimalsNum) {
+        this.width = width;
+        this.height = height;
+        this.jungleRatio = jungleRatio;
+        this.moveEnergy = moveEnergy;
+        this.plantEnergy = plantEnergy;
+        this.initialAnimalsNum = initialAnimalsNum;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public double getJungleRatio() {
+        return jungleRatio;
+    }
+
+    public double getMoveEnergy() {
+        return moveEnergy;
+    }
+
+    public double getPlantEnergy() {
+        return plantEnergy;
+    }
+
+    public int getInitialAnimalsNum() {
+        return initialAnimalsNum;
+    }
+}

src/simulation/Day.java

@@ -0,0 +1,9 @@
+package simulation;
+
+import java.util.*;
+
+public class Day{
+
+    Board board;
+
+}

src/simulation/Direction.java

@@ -0,0 +1,31 @@
+package simulation;
+
+public enum Direction {
+    NORTH(0, 1),
+    NORTHEAST(1, 1),
+    EAST(1, 0),
+    SOUTHEAST(1, -1),
+    SOUTH(0, -1),
+    SOUTHWEST(-1, -1),
+    WEST(-1, 0),
+    NORTHWEST(-1, 1);
+    private final int x;
+    private final int y;
+
+    Direction(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Direction shiftedBy(int step){
+        return Direction.values()[(this.ordinal()+step)%8];
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+}

src/simulation/Genome.java

@@ -0,0 +1,44 @@
+package simulation;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class Genome {
+    private final List<Integer> genes;
+    private int length;
+
+    Genome(int length){
+        Random rng = new Random();
+        List<Integer> genes;
+        do {
+            genes = new ArrayList<>();
+            for (int i = 0; i < length; i++) {
+                genes.add(rng.nextInt(8));
+            }
+        } while (! this.isValid());
+        this.genes = (List<Integer>) genes.stream().sorted();
+        this.length = length;
+    };
+
+    Genome(Genome g1, Genome g2){
+        Random rng = new Random();
+        List<Integer> genes = new ArrayList<>();
+        int breakpt1 = rng.nextInt(31);
+        int breakpt2 = breakpt1 + 1 + rng.nextInt(31-breakpt1);
+
+        this.genes = genes;
+    };
+
+    public int pickRandomGene(){
+        int i = new Random().nextInt(genes.size());
+        return genes.get(i);
+    }
+
+    public boolean isValid(){
+        // checks if the genome contains all 8 genes
+        int bitMask = 0;
+        for (int gene : genes) bitMask |= (1 << gene);
+        return bitMask == (2^8 - 1);
+    }
+}

src/simulation/Location.java

@@ -0,0 +1,25 @@
+package simulation;
+
+public class Location implements Comparable<Location>{
+    private final int x;
+    private final int y;
+
+    Location(int x,int y){
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public int compareTo(Location o) {
+        if (this.getX() == o.getX()) return this.getY() - o.getY();
+        else return this.getX() - o.getX();
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+}

src/simulation/Simulation.java

@@ -0,0 +1,32 @@
+package simulation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Simulation {
+
+    private List<Day> day = new ArrayList<Day>();
+    private final BoardParams params;
+    private int currentDay = 0;
+    private final String name;
+
+
+    public Simulation(String name, BoardParams params) {
+        this.name = name;
+        this.params = params;
+    }
+
+
+
+    public int getCurrentDay() {
+        return currentDay;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public BoardParams getParams() {
+        return this.params;
+    }
+}

src/simulation/SimulationErrorException.java

@@ -0,0 +1,7 @@
+package simulation;
+
+public class SimulationErrorException extends Exception{
+    public SimulationErrorException(String errorMessage) {
+        super(errorMessage);
+    }
+}

test/simulation/LocationTest.java

@@ -0,0 +1,33 @@
+package simulation;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LocationTest {
+    Location l1 = new Location(1,4);
+    Location l2 = new Location(1,2);
+    Location l3 = new Location(3,5);
+    Location l4 = new Location(3,0);
+    @Test
+    void compareTo() {
+        assertTrue(l1.compareTo(l2) > 0);
+        assertTrue(l1.compareTo(l3) < 0);
+        assertTrue(l1.compareTo(l4) < 0);
+        assertTrue(l2.compareTo(l1) < 0);
+        assertTrue(l2.compareTo(l3) < 0);
+        assertTrue(l2.compareTo(l4) < 0);
+        assertTrue(l3.compareTo(l4) > 0);
+        assertTrue(l2.compareTo(l1) < 0);
+        assertTrue(l3.compareTo(l1) > 0);
+        assertTrue(l4.compareTo(l1) > 0);
+        assertTrue(l1.compareTo(l2) > 0);
+        assertTrue(l3.compareTo(l2) > 0);
+        assertTrue(l4.compareTo(l2) > 0);
+        assertTrue(l4.compareTo(l3) < 0);
+        assertTrue(l1.compareTo(l1) == 0);
+        assertTrue(l2.compareTo(l2) == 0);
+        assertTrue(l3.compareTo(l3) == 0);
+        assertTrue(l4.compareTo(l4) == 0);
+    }
+}