developed the gen alg. fixed issues

Author: boraakoguz

JavaRacer/Agent.java

@@ -15,7 +15,8 @@ public class Agent {
     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 int laps = 0;
+    public double points = 0;
     public boolean onFinishLine, offFinishLine, isCollided = false; //flags for game logic
     public ArrayList<Integer> instructions;
     int nextActionTimer,instructionIndex;
@@ -126,11 +127,11 @@ public void calculatePoints(){
                 points-=1000;
                 isCollided = true;
             }
-            points -= 2*velocity.netVelocity()/frictionCoefficient;
+            points -= (velocity.netVelocity()/frictionCoefficient)/10;
         }
         else{
             isCollided = false;
-            points += velocity.netVelocity();
+            points += velocity.netVelocity()/10;
         }
         if(points<0){
             points = 0;
@@ -158,6 +159,7 @@ public void draw(Graphics2D graphics){
     }
     public void reset(){
         this.isFinished = false;
+        this.instructionIndex = 0;
         this.agentX=MapLoader.spawnX*gameWindow.tileSize;
         this.agentY=MapLoader.spawnY*gameWindow.tileSize;
         velocity.X = 0;
@@ -189,7 +191,7 @@ public int getAgentX(){
     public int getAgentY(){
         return this.agentY;
     }
-    public int getPoints(){
+    public double getPoints(){
         return this.points;
     }
     public int getLaps(){

JavaRacer/GameWindow.java

@@ -61,7 +61,9 @@ public void update(){
         for(int i = 0; i<agents.length;i++){
             agents[i].update();
         }
-        genAlg.checkGeneration();
+        if(genAlg.generationNumber<genAlg.NUMBER_OF_GENERATIONS){
+            genAlg.checkGeneration();
+        }
         camera.update();
     }
     public void paintComponent(Graphics graphics){

JavaRacer/GenerationAlgorithm.java

@@ -5,54 +5,118 @@
 import java.util.Random;
 
 public class GenerationAlgorithm {
-    public final int POPULATION;
-    public final int NUMBER_OF_GENERATIONS = 10;
+    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;
+    public final int    MAX_MUTATION_COUNT = 5;
+    public final int    ELITISM_NUMBER = 2;
+    public final int    NUMBER_OF_GENERATIONS_PER_INCREASE = 10;
     static Random rand = new Random(0);
-    int[] eliteIndexes = new int[ELITISM_NUMBER];
+    ArrayList<Integer> eliteIndexes = new ArrayList<Integer>();
     int generationNumber = 0;
-    boolean sessionStarted = false;
+    int instructionSize = 20;
     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();
+        if(agents[agents.length-1].isFinished){
+            ArrayList<Double> fitnesses = getFitness();
+            ArrayList<Double> weights = getWeights(fitnesses);
+            ArrayList<Integer[]> parentsList = getParents(weights);
+            for (Integer[] integers : parentsList) {
+                System.out.println(Arrays.toString(integers));
+            }
+            System.out.printf("Generation completed number: %d\n",generationNumber);
+            crossOver(parentsList);
             for(Agent agent : agents){
                 agent.reset();
             }
-            sessionStarted = true;
             generationNumber++;
         }
     }
     public void createPopulation(){
         for (Agent agent : agents) {
-            assignRandomInstructions(agent,20);
+            assignRandomInstructions(agent,instructionSize);
         }
     }
     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<>();
+    public ArrayList<Double> getFitness(){
+        ArrayList<Double> fitness = new ArrayList<>();
         for (Agent agent : agents) {
             fitness.add(agent.getPoints());
         }
-        ArrayList<Integer> fitnessCopy = new ArrayList<>(fitness);
+        ArrayList<Double> 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));
+            eliteIndexes.add(fitness.indexOf(fitnessCopy.get(i)));
         }
-        System.out.println(fitness.toString());
-        System.out.println(Arrays.toString(eliteIndexes));
         return fitness;
     }
-
+    public ArrayList<Double> getWeights(ArrayList<Double> fitness){
+        double sum = 0;
+        ArrayList<Double> weights = new ArrayList<Double>();
+        for (double d : fitness) {
+            sum += Math.exp(d);
+        }
+        for (int i = 0; i<fitness.size();i++) {
+            double softMaxed = Math.exp(fitness.get(i))/sum;
+            weights.add(softMaxed);
+        }
+        return weights;
+    }
+    public ArrayList<Integer[]> getParents(ArrayList<Double> weights){
+        ArrayList<Integer[]> parentsList = new ArrayList<Integer[]>();
+        double totalWeight = 0.0; //in case the sum of weights is not 1
+        for (double i : weights) {
+            totalWeight += i;
+        }
+        for(int i = 0; i<weights.size(); i++){
+            Integer[] parents = new Integer[2];
+            for(int j = 0; j<2;j++){
+                int idx = 0;
+                for (double r = Math.random() * totalWeight; idx < weights.size() - 1; ++idx) {
+                    r -= weights.get(idx);
+                    if (r <= 0.0) break;
+                }
+                parents[j] = idx;
+            }
+            parentsList.add(parents);
+        }
+        return parentsList;
+    }
+    public void crossOver(ArrayList<Integer[]> parents){
+        ArrayList<ArrayList<Integer>> instructionsTemp = new ArrayList<ArrayList<Integer>>();
+        for(int i = 0; i<POPULATION; i++){
+            instructionsTemp.add(agents[i].instructions);
+        }
+        for (int i = 0; i<parents.size();i++) {
+            Integer[] parentPair = parents.get(i);
+            if(eliteIndexes.contains(parentPair[0])){
+                continue;
+            }
+            if(parentPair[0] != parentPair[1]){
+                int crossOverLength = rand.nextInt(10);
+                int indexOfCrossing = rand.nextInt(agents[parentPair[0]].instructions.size()-crossOverLength);
+                for(int j = indexOfCrossing; j<indexOfCrossing+crossOverLength;j++){
+                    agents[parentPair[0]].instructions.set(j,instructionsTemp.get(parentPair[1]).get(j));
+                }
+            }
+            if(Math.random()<MUTATION_CHANCE){
+                int numberOfMutations = rand.nextInt(MAX_MUTATION_COUNT);
+                for(int m = 0; m<numberOfMutations;m++){
+                    int randomInstructionIndex = rand.nextInt(agents[parentPair[0]].instructions.size());
+                    agents[parentPair[0]].instructions.set(randomInstructionIndex,rand.nextInt(5)); //randomize instructions
+                }
+            }
+            
+        } 
+    }
 }

pipline.txt

@@ -2,9 +2,9 @@
 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
+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
+10. set population to new population and continue+