Many improvements to evolutionSteer !

.gitattributes

@@ -0,0 +1 @@
++*.pde  text eol=lf whitespace=blank-at-eol,-blank-at-eof,-space-before-tab,tab-in-indent,tabwidth=2 

.gitignore

@@ -0,0 +1,7 @@
+
+data/autosave\.gz
+data/*\.gz
+
+error\.log
+
+data/tempfile\.gz

Axon.pde

@@ -1,4 +1,4 @@
-class Axon{
+class Axon {
   final double MUTABILITY_MUTABILITY = 0.7;
   final int mutatePower = 9;
   final double MUTATE_MULTI;
@@ -8,9 +8,12 @@ class Axon{
   public Axon(double w, double m){
     weight = w;
     mutability = m;
-    MUTATE_MULTI = Math.pow(0.5,mutatePower);
+    MUTATE_MULTI = Math.pow(0.8,mutatePower);
   }
 
+  public Axon copyAxon(){
+    return new Axon(this.weight,this.mutability);
+  }
   public Axon mutateAxon(){
     double mutabilityMutate = Math.pow(0.5,pmRan()*MUTABILITY_MUTABILITY);
     return new Axon(weight+r()*mutability/MUTATE_MULTI,mutability*mutabilityMutate);
@@ -21,4 +24,26 @@ class Axon{
   public double pmRan(){
     return (Math.random()*2-1);
   }
-}
+
+  public void saveToJson(JsonGenerator g){
+    try {
+      g.writeNumberField("weight", weight);
+      g.writeNumberField("mutability", mutability);
+    } catch(Exception e){
+        writeToErrorLog(e);
+    }
+  }
+
+  public void loadFromJson(JsonParser p){
+    try{
+       while(p.nextToken() != JsonToken.END_OBJECT){
+         String fieldName = p.getCurrentName();
+         p.nextToken();
+         if(fieldName.equals("weight")){ this.weight = p.getDoubleValue(); }
+         else if(fieldName.equals("mutability")){ this.mutability = p.getDoubleValue(); }
+      }
+    } catch(Exception e){
+      writeToErrorLog(e);
+    }
+  }
+}

Brain.pde

@@ -1,37 +1,39 @@
 class Brain {
+  float heartbeatInterval = (float)(Math.PI/12);
+  int timesUsed;
   float[][] neurons;
   Axon[][][] axons;
   int BRAIN_WIDTH = 0;
   int BRAIN_HEIGHT = 0;
   Brain(int bw, int bh, Axon[][][] templateAxons, Boolean haveNeurons, Boolean mutate){ //This is to copy a brain EXACTLY.
     setUpBasics(bw,bh,haveNeurons);
-    axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT-1];
+    axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT];
     if(mutate){
       for(int x = 0; x < BRAIN_WIDTH-1; x++){
         for(int y = 0; y < BRAIN_HEIGHT; y++){
-          for(int z = 0; z < BRAIN_HEIGHT-1; z++){
+          for(int z = 0; z < BRAIN_HEIGHT; z++){
             axons[x][y][z] = templateAxons[x][y][z].mutateAxon();
           }
         }
       }
     }else{
       for(int x = 0; x < BRAIN_WIDTH-1; x++){
         for(int y = 0; y < BRAIN_HEIGHT; y++){
-          for(int z = 0; z < BRAIN_HEIGHT-1; z++){
-            axons[x][y][z] = new Axon(templateAxons[x][y][z].weight,templateAxons[x][y][z].mutability);
+          for(int z = 0; z < BRAIN_HEIGHT; z++){
+            axons[x][y][z] = templateAxons[x][y][z].copyAxon();
           }
         }
       }
     }
   }
   Brain(int bw, int bh){
     setUpBasics(bw,bh,false);
-    axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT-1];
+    axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT];
     for(int x = 0; x < BRAIN_WIDTH-1; x++){
       for(int y = 0; y < BRAIN_HEIGHT; y++){
-        for(int z = 0; z < BRAIN_HEIGHT-1; z++){
+        for(int z = 0; z < BRAIN_HEIGHT; z++){
           double startingWeight = 0;
-          if(y == BRAIN_HEIGHT-1){
+          if(y == BRAIN_HEIGHT - 1){
             startingWeight = (Math.random()*2-1)*STARTING_AXON_VARIABILITY;
           }
           axons[x][y][z] = new Axon(startingWeight,AXON_START_MUTABILITY);
@@ -42,10 +44,10 @@ class Brain {
   void changeBrainStructure(int bw, int bh, int rowInsertionIndex, int rowRemovalIndex){
     setUpBasics(bw,bh,false);
     Axon[][][] oldAxons = axons;
-    axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT-1];
+    axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT];
     for(int x = 0; x < BRAIN_WIDTH-1; x++){
       for(int y = 0; y < BRAIN_HEIGHT; y++){
-        for(int z = 0; z < BRAIN_HEIGHT-1; z++){
+        for(int z = 0; z < BRAIN_HEIGHT; z++){
           if(y == rowInsertionIndex || z == rowInsertionIndex){
             double startingWeight = 0;
             if(y == BRAIN_HEIGHT-1 || true){
@@ -66,6 +68,7 @@ class Brain {
     }
   }
   void setUpBasics(int bw, int bh, Boolean haveNeurons){
+    timesUsed = 0;
     BRAIN_WIDTH = bw;
     BRAIN_HEIGHT = bh;
     if(haveNeurons){
@@ -80,50 +83,106 @@ class Brain {
         }
       }
     }else{
-      neurons = null;
+      neurons = new float[BRAIN_WIDTH][BRAIN_HEIGHT];//null;
     }
   }
   public void useBrain(Creature owner){
-    ArrayList<Node> n = owner.n;
-    ArrayList<Muscle> m = owner.m;
+    final ArrayList<Node> n = owner.n;
+    final ArrayList<Muscle> m = owner.m;
     for(int i = 0; i < n.size(); i++){
       Node ni = n.get(i);
-      neurons[0][i] = dist(ni.x, ni.y, ni.z, foodX, foodY, foodZ);
+      neurons[0][i] = dist(ni.x, ni.y, ni.z, owner.foodX, owner.foodY, owner.foodZ);
     }
+
     for(int i = 0; i < m.size(); i++){
       Muscle am = m.get(i);
       Node ni1 = n.get(am.c1);
       Node ni2 = n.get(am.c2);
       neurons[0][n.size()+i] = dist(ni1.x, ni1.y, ni1.z, ni2.x, ni2.y, ni2.z)/am.len;
     }
+
+    neurons[0][n.size()+m.size()] = sin(heartbeatInterval*timesUsed);
+    neurons[0][n.size()+m.size()+1] = cos(2*heartbeatInterval*timesUsed);
+    timesUsed += 1;
+
     for(int x = 1; x < BRAIN_WIDTH; x++){
-      for(int y = 0; y < BRAIN_HEIGHT-1; y++){
+      for(int y = 0; y < BRAIN_HEIGHT; y++){
         float total = 0;
         for(int input = 0; input < BRAIN_HEIGHT; input++){
           total += neurons[x-1][input]*axons[x-1][input][y].weight;
         }
-        if(x == BRAIN_WIDTH-1){
-          neurons[x][y] = total;
-        }else{
-          neurons[x][y] = sigmoid(total);
+        if(x == BRAIN_WIDTH - 1){
+          neurons[x][y] = sigmoidapprox(total);
+        } else {
+          neurons[x][y] = linear(total);
         }
       }
     }
+    for(int i = 0; i < n.size(); i++){
+      n.get(i).brainOutput = neurons[BRAIN_WIDTH-1][i];
+    }
     for(int i = 0; i < m.size(); i++){
       m.get(i).brainOutput = neurons[BRAIN_WIDTH-1][n.size()+i];
     }
   }
+  public float linear(float input){
+    if(input >= -5 || input <= 5){
+      return input/5;
+    }
+    else if(input < -5){
+      return -1;
+    }
+    else{
+      return 1;
+    }
+  }
   public float sigmoid(float input){
-    return 1.0/(1.0+pow(2.71828182846,-input));
+    return -1.0+(2.0/(1.0+pow(2.71828182846,-input)));
+    // Sigmoid centered on 0 and giving response between -1 and +1
+  }
+  public float sigmoidapprox(float input){
+    if(input >= -1.1779 && input <= 1.1779){
+       return 0.5*input;
+    } else if(input >= -2.7537 && input < -1.1779){
+       return 0.210*input-0.3416;
+    } else if(input > 1.1779 && input <= 2.7537){
+       return 0.210*input+0.3416;
+    } else if(input >= -5 && input < -2.7537){
+       return 0.0354*input-0.8224;
+    } else if(input > 3 && input <= 5){
+       return 0.0354*input+0.8224;
+    } else if(input < -5){
+       return 0;
+    } else {
+       return 1;
+    }
   }
   Brain getUsableCopyOfBrain(){
-    return new Brain(BRAIN_WIDTH,BRAIN_HEIGHT,axons,true,false);
+    return new Brain(BRAIN_WIDTH,BRAIN_HEIGHT,axons.clone(),true,false);
   }
   Brain copyBrain(){
-    return new Brain(BRAIN_WIDTH,BRAIN_HEIGHT,axons,false,false);
+    return new Brain(BRAIN_WIDTH,BRAIN_HEIGHT,axons.clone(),false,false);
   }
   Brain copyMutatedBrain(){
-    return new Brain(BRAIN_WIDTH,BRAIN_HEIGHT,axons,false,true);
+    return new Brain(BRAIN_WIDTH,BRAIN_HEIGHT,axons.clone(),false,true);
+  }
+  Brain copyExpandedBrain(){
+    Axon[][][] extaxons = new Axon[BRAIN_WIDTH][BRAIN_HEIGHT][BRAIN_HEIGHT];
+    for(int x = 0; x < BRAIN_WIDTH; x++){
+        for(int y = 0; y < BRAIN_HEIGHT; y++){
+          for(int z = 0; z < BRAIN_HEIGHT; z++){
+            if(x == 0){ 
+              if(y == z){
+                extaxons[x][y][z] = new Axon(5.0,AXON_START_MUTABILITY);
+              } else {
+                extaxons[x][y][z] = new Axon(0.0,AXON_START_MUTABILITY);
+              }
+            }
+            else{ extaxons[x][y][z] = axons[x-1][y][z].copyAxon(); }
+          }
+        }
+      }
+    return new Brain(BRAIN_WIDTH+1,BRAIN_HEIGHT,extaxons.clone(),false,false);
   }
   public void drawBrain(float scaleUp, Creature owner){
     ArrayList<Node> n = owner.n;
@@ -153,7 +212,7 @@ class Brain {
     }
     for(int x = 0; x < BRAIN_WIDTH-1; x++){
       for(int y = 0; y < BRAIN_HEIGHT; y++){
-        for(int z = 0; z < BRAIN_HEIGHT-1; z++){
+        for(int z = 0; z < BRAIN_HEIGHT; z++){
           drawAxon(x,y,x+1,z,scaleUp);
         }
       }
@@ -177,4 +236,91 @@ class Brain {
       return color(255,255,255);
     }
   }
-}
+
+  public void saveToJson(JsonGenerator g){
+    try{ 
+      g.writeNumberField("width", BRAIN_WIDTH);
+      g.writeNumberField("height", BRAIN_HEIGHT);
+      if(axons != null){
+         g.writeArrayFieldStart("axons");
+         for (int i = 0; i < axons.length; i++){
+           g.writeStartArray();
+           for(int j = 0; j < axons[i].length; j++){
+             g.writeStartArray();
+             for(int k = 0; k < axons[i][j].length; k++){
+               g.writeStartObject(); axons[i][j][k].saveToJson(g); g.writeEndObject();
+             }
+             g.writeEndArray();
+           }
+           g.writeEndArray();
+         }
+         g.writeEndArray();
+      }
+      if(neurons != null){
+         g.writeArrayFieldStart("neurons");
+         for(int i = 0; i < neurons.length; i++){
+           g.writeStartArray();
+           for(int j = 0; j < neurons[i].length; j++){
+             g.writeNumber(neurons[i][j]);
+           }
+           g.writeEndArray();
+         }
+         g.writeEndArray();
+      }
+    } catch(Exception e){
+        writeToErrorLog(e);
+    }
+  }
+
+  public void loadFromJson(JsonParser p){
+    try{
+       while(p.nextToken() != JsonToken.END_OBJECT){
+         String fieldName = p.getCurrentName();
+         JsonToken token = p.nextToken();
+         if(fieldName.equals("width")){ this.BRAIN_WIDTH = p.getIntValue(); }
+         else if(fieldName.equals("height")){ this.BRAIN_HEIGHT = p.getIntValue(); }
+         else if(fieldName.equals("axons")){
+           if (token != JsonToken.START_ARRAY) { throw new IOException("Expected Array"); }
+           int i = 0;
+           axons = new Axon[BRAIN_WIDTH-1][BRAIN_HEIGHT][BRAIN_HEIGHT];
+           while((token = p.nextToken()) != JsonToken.END_ARRAY){
+             if (token == JsonToken.START_ARRAY){
+               int j = 0;
+               while((token = p.nextToken()) != JsonToken.END_ARRAY){
+                 if (token == JsonToken.START_ARRAY){
+                   int k = 0;
+                   while((token = p.nextToken()) != JsonToken.END_ARRAY){
+                     if (token != JsonToken.START_OBJECT) { throw new Exception("Expected Object"); }
+                     axons[i][j][k] = new Axon(0,0);
+                     axons[i][j][k].loadFromJson(p);
+                     k += 1;
+                   }
+                 }
+                 j += 1;
+               }
+             }
+             i += 1;
+           }
+         }
+         else if(fieldName.equals("neurons")){
+           if (token != JsonToken.START_ARRAY) { throw new IOException("Expected Array"); }
+           int i = 0;
+           neurons = new float[BRAIN_WIDTH][BRAIN_HEIGHT];
+           while((token = p.nextToken()) != JsonToken.END_ARRAY){
+             if (token == JsonToken.START_ARRAY){
+               int j = 0;
+               while(p.nextToken() != JsonToken.END_ARRAY){
+                 neurons[i][j] = p.getFloatValue();
+                 j += 1;
+               }
+             }
+             i += 1;
+           }
+         }
+      }
+    } catch(Exception e){
+      writeToErrorLog(e);
+    }
+  }
+
+}