added generation algorithm basics, added pipeline

Author: boraakoguz

JavaRacer/Agent.java

@@ -6,24 +6,23 @@
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
-import java.util.Random;
+import java.util.ArrayList;
+
 import javax.imageio.ImageIO;
 
 public class Agent {
-    static Random rand = new Random(0);
-
     int agentX,agentY; //x,y coordinates in the world and rotation of the car in degrees. 0 representing right as in cartesian system(stored in velocity)
     int screenX, screenY; //the x,y coordinates of the car on screen
     Rectangle solidArea = new Rectangle(); // aka hitbox of the car
     public double frictionCoefficient; //road friction: 1 in asphalt, 0.1 in grass checked by CollisionControl class
     public int points, laps = 0;
     public boolean onFinishLine, offFinishLine, isCollided = false; //flags for game logic
-    public int[] instructions = new int[100];
+    public ArrayList<Integer> instructions;
     int nextActionTimer,instructionIndex;
+    public boolean isFinished = false;
     public BufferedImage playerModel;
     GameWindow gameWindow;
     Velocity velocity;
-    int counter;
 
     public Agent(GameWindow gw){
         this.gameWindow = gw;
@@ -32,12 +31,8 @@ public Agent(GameWindow gw){
     public void setDefault(){
         this.agentX=MapLoader.spawnX*gameWindow.tileSize;
         this.agentY=MapLoader.spawnY*gameWindow.tileSize;
-        this.velocity = new Velocity();
-        
-        for(int i = 0; i<50; i++){
-            instructions[i] = rand.nextInt(5);
-        }
-        
+        this.velocity = new Velocity();   
+        this.instructions = new ArrayList<Integer>();    
         switch (MapLoader.spawnDirection) {
             case 0:
                 velocity.angle = 0;
@@ -58,7 +53,6 @@ public void setDefault(){
         this.solidArea.y = 5;
         this.solidArea.width = 25;
         this.solidArea.height = 25;
-    
         try {
             File tmp = new File("source/car.png");
             playerModel = ImageIO.read(tmp);
@@ -70,10 +64,10 @@ public void update(){
         frictionCoefficient = gameWindow.collisionControl.checkCollision(this);
         checkLaps();
         calculatePoints();
-        if(nextActionTimer%5 == 0 && instructionIndex<instructions.length){
+        if(nextActionTimer%5 == 0 && instructionIndex<instructions.size()){ //take action every 5 frames
             int rotationAngle;
             double netVelocity = velocity.netVelocity();
-            switch (instructions[instructionIndex]) {
+            switch (instructions.get(instructionIndex)) {
                 case 0: //accelerate
                     velocity.accelerate(0.4*frictionCoefficient);
                     break;
@@ -107,6 +101,9 @@ public void update(){
         while(frictionCoefficient<1&&velocity.netVelocity()>10*frictionCoefficient){
             velocity.accelerate(-0.5);
         }
+        if(instructionIndex == instructions.size()-1){
+            this.isFinished = true;
+        }
         this.agentX += velocity.X;
         this.agentY -= velocity.Y;
         nextActionTimer++;
@@ -159,6 +156,30 @@ public void draw(Graphics2D graphics){
             graphics.setTransform(oldTransform); // restore old graphics
         }
     }
+    public void reset(){
+        this.isFinished = false;
+        this.agentX=MapLoader.spawnX*gameWindow.tileSize;
+        this.agentY=MapLoader.spawnY*gameWindow.tileSize;
+        velocity.X = 0;
+        velocity.Y = 0;
+        switch (MapLoader.spawnDirection) {
+            case 0:
+                velocity.angle = 0;
+                break;
+            case 1:
+                velocity.angle = 90;
+                break;
+            case 2:
+                velocity.angle = 180;
+                break;
+            case 3:
+                velocity.angle = 270;
+                break;
+            default:
+                break;
+        }
+
+    }
     public String toString(){
         return this.agentX + " " + this.agentY;
     }

JavaRacer/GameWindow.java

@@ -18,12 +18,14 @@ public class GameWindow extends JPanel implements Runnable{
     Agent[] agents = new Agent[10];
     CollisionControl collisionControl = new CollisionControl(this);
     Camera camera;
+    GenerationAlgorithm genAlg;
 
     public GameWindow(){
         Color backgroundColor = new Color(34, 139, 34);
         for(int i = 0; i<agents.length;i++){
             agents[i] = new Agent(this);        
         }
+        this.genAlg = new GenerationAlgorithm(agents);
         this.camera = new Camera(this,keyHandle, agents[0].agentX, agents[0].agentY);
         this.setBackground(backgroundColor);
         this.setPreferredSize(new Dimension(WIDTH, HEIGHT));
@@ -59,6 +61,7 @@ public void update(){
         for(int i = 0; i<agents.length;i++){
             agents[i].update();
         }
+        genAlg.checkGeneration();
         camera.update();
     }
     public void paintComponent(Graphics graphics){

JavaRacer/GenerationAlgorithm.java

@@ -0,0 +1,58 @@
+package JavaRacer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Random;
+
+public class GenerationAlgorithm {
+    public final int POPULATION;
+    public final int NUMBER_OF_GENERATIONS = 10;
+    public final double MUTATION_CHANCE = 0.1;
+    public final int ELITISM_NUMBER = 5;
+    public final int NUMBER_OF_GENERATIONS_PER_INCREASE = 10;
+    static Random rand = new Random(0);
+    int[] eliteIndexes = new int[ELITISM_NUMBER];
+    int generationNumber = 0;
+    boolean sessionStarted = false;
+    Agent[] agents;
+    public GenerationAlgorithm(Agent[] agents){
+        this.agents = agents;
+        this.POPULATION = agents.length;
+        createPopulation();
+    }
+    public void checkGeneration(){
+        if(agents[agents.length-1].isFinished && !sessionStarted){
+            getFitness();
+            for(Agent agent : agents){
+                agent.reset();
+            }
+            sessionStarted = true;
+            generationNumber++;
+        }
+    }
+    public void createPopulation(){
+        for (Agent agent : agents) {
+            assignRandomInstructions(agent,20);
+        }
+    }
+    public void assignRandomInstructions(Agent agent,int size){
+        for(int i = 0; i<size;i++){
+            agent.instructions.add(rand.nextInt(5));
+        }
+    }
+    public ArrayList<Integer> getFitness(){
+        ArrayList<Integer> fitness = new ArrayList<>();
+        for (Agent agent : agents) {
+            fitness.add(agent.getPoints());
+        }
+        ArrayList<Integer> fitnessCopy = new ArrayList<>(fitness);
+        Collections.sort(fitnessCopy, Collections.reverseOrder(null));
+        for(int i = 0; i<ELITISM_NUMBER;i++){
+            eliteIndexes[i] = fitness.indexOf(fitnessCopy.get(i));
+        }
+        System.out.println(fitness.toString());
+        System.out.println(Arrays.toString(eliteIndexes));
+        return fitness;
+    }
+
+}

pipline.txt

@@ -0,0 +1,10 @@
+1. create a population with rand properties +
+2. iterate over number of generations
+3. calculate fitness of each agent (points) +
+4. in the fitness array get the (elitism_number) of agents starting from the best. +
+5. calculate probability values of the array using softmax  
+6. using the above weights, get randomly chosen pairs from the array and append to a parents_list where each element contains 2 agents
+7. iterate over population and create childs of these parents using crossover.
+8. use random to determine whether to mutate or not
+9. directly append elite agents
+10. set population to new population and continue