├── README.md
└── SmartSnakesCombine
    ├── Food.pde
    ├── Matrix.pde
    ├── NeuralNet.pde
    ├── Population.pde
    ├── SmartSnakesCombine.pde
    ├── Snake.pde
    ├── SuperSnake.pde
    ├── SuperSnakeClone.pde
    ├── World.pde
    └── data
        └── snakesStored.csv


/README.md:
--------------------------------------------------------------------------------
 1 | # SnakeFusion
 2 | Using the genetic algorithm and neural networks I trained up 5 snakes who will then fuse to become the ultimate snake, this is how I did it
 3 | 
 4 | The program I used to write and run this code was processing https://processing.org/download/
 5 | 
 6 | If you get it working some instructions
 7 | press Space to just show the current best from  each population
 8 | press d to double the mutation rate
 9 | press h to halve it 
10 | after you run it some snakes will be saved press 0 to 4 to check them out
11 | to further train the snakes of legend (the saved snakes) press L
12 | to fuse snakes together to create a super snake press f
13 | 
14 | 
15 | I hope my commenting makes sense 
16 | 
17 | Have fun :)
18 | 


--------------------------------------------------------------------------------
/SmartSnakesCombine/Food.pde:
--------------------------------------------------------------------------------
 1 | class Food {
 2 |   PVector pos;//position of food
 3 | 
 4 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 5 |   //constructor
 6 |   Food() {
 7 |     
 8 | 
 9 |     pos = new PVector();
10 |     // set position to a random spot 
11 |     pos.x = 400+floor(random(0, 40)) * 10;
12 |     pos.y = floor(random(0, 40)) * 10;
13 |   }
14 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
15 |   //show the food as a red square
16 |   void show() {
17 |     fill(255, 0, 0);
18 |     rect(pos.x, pos.y, 10, 10);
19 |   }
20 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
21 |   //return a clone of this food 
22 |   Food clone() {
23 |     Food clone = new Food();
24 |     clone.pos = new PVector(pos.x, pos.y);
25 | 
26 |     
27 |     return clone;
28 |   }
29 | 
30 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/Matrix.pde:
--------------------------------------------------------------------------------
  1 | 
  2 | class Matrix {
  3 |   
  4 |   //local variables
  5 |   int rows;
  6 |   int cols;
  7 |   float[][] matrix;
  8 |   
  9 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 10 |   //constructor
 11 |   Matrix(int r, int c) {
 12 |     rows = r;
 13 |     cols = c;
 14 |     matrix = new float[rows][cols];
 15 |   }
 16 |   
 17 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 18 |   //constructor from 2D array
 19 |   Matrix(float[][] m) {
 20 |     matrix = m;
 21 |     cols = m.length;
 22 |     rows = m[0].length;
 23 |   }
 24 |   
 25 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 26 |   //print matrix
 27 |   void output() {
 28 |     for (int i =0; i<rows; i++) {
 29 |       for (int j = 0; j<cols; j++) {
 30 |         print(matrix[i][j] + "  ");
 31 |       }
 32 |       println(" ");
 33 |     }
 34 |     println();
 35 |   }
 36 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 37 |   
 38 |   //multiply by scalar
 39 |   void multiply(float n ) {
 40 | 
 41 |     for (int i =0; i<rows; i++) {
 42 |       for (int j = 0; j<cols; j++) {
 43 |         matrix[i][j] *= n;
 44 |       }
 45 |     }
 46 |   }
 47 | 
 48 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 49 |   //return a matrix which is this matrix dot product parameter matrix 
 50 |   Matrix dot(Matrix n) {
 51 |     Matrix result = new Matrix(rows, n.cols);
 52 |    
 53 |     if (cols == n.rows) {
 54 |       //for each spot in the new matrix
 55 |       for (int i =0; i<rows; i++) {
 56 |         for (int j = 0; j<n.cols; j++) {
 57 |           float sum = 0;
 58 |           for (int k = 0; k<cols; k++) {
 59 |             sum+= matrix[i][k]*n.matrix[k][j];
 60 |           }
 61 |           result.matrix[i][j] = sum;
 62 |         }
 63 |       }
 64 |     }
 65 | 
 66 |     return result;
 67 |   }
 68 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 69 |   //set the matrix to random ints between -1 and 1
 70 |   void randomize() {
 71 |     for (int i =0; i<rows; i++) {
 72 |       for (int j = 0; j<cols; j++) {
 73 |         matrix[i][j] = random(-1, 1);
 74 |       }
 75 |     }
 76 |   }
 77 | 
 78 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 79 |   //add a scalar to the matrix
 80 |   void Add(float n ) {
 81 |     for (int i =0; i<rows; i++) {
 82 |       for (int j = 0; j<cols; j++) {
 83 |         matrix[i][j] += n;
 84 |       }
 85 |     }
 86 |   }
 87 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 88 |   ///return a matrix which is this matrix + parameter matrix
 89 |   Matrix add(Matrix n ) {
 90 |     Matrix newMatrix = new Matrix(rows, cols);
 91 |     if (cols == n.cols && rows == n.rows) {
 92 |       for (int i =0; i<rows; i++) {
 93 |         for (int j = 0; j<cols; j++) {
 94 |           newMatrix.matrix[i][j] = matrix[i][j] + n.matrix[i][j];
 95 |         }
 96 |       }
 97 |     }
 98 |     return newMatrix;
 99 |   }
100 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
101 |   //return a matrix which is this matrix - parameter matrix
102 |   Matrix subtract(Matrix n ) {
103 |     Matrix newMatrix = new Matrix(cols, rows);
104 |     if (cols == n.cols && rows == n.rows) {
105 |       for (int i =0; i<rows; i++) {
106 |         for (int j = 0; j<cols; j++) {
107 |           newMatrix.matrix[i][j] = matrix[i][j] - n.matrix[i][j];
108 |         }
109 |       }
110 |     }
111 |     return newMatrix;
112 |   }
113 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
114 |   //return a matrix which is this matrix * parameter matrix (element wise multiplication)
115 |   Matrix multiply(Matrix n ) {
116 |     Matrix newMatrix = new Matrix(rows, cols);
117 |     if (cols == n.cols && rows == n.rows) {
118 |       for (int i =0; i<rows; i++) {
119 |         for (int j = 0; j<cols; j++) {
120 |           newMatrix.matrix[i][j] = matrix[i][j] * n.matrix[i][j];
121 |         }
122 |       }
123 |     }
124 |     return newMatrix;
125 |   }
126 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
127 |   //return a matrix which is the transpose of this matrix
128 |   Matrix transpose() {
129 |     Matrix n = new Matrix(cols, rows);
130 |     for (int i =0; i<rows; i++) {
131 |       for (int j = 0; j<cols; j++) {
132 |         n.matrix[j][i] = matrix[i][j];
133 |       }
134 |     }
135 |     return n;
136 |   }
137 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
138 |   //Creates a single column array from the parameter array
139 |   Matrix singleColumnMatrixFromArray(float[] arr) {
140 |     Matrix n = new Matrix(arr.length, 1);
141 |     for (int i = 0; i< arr.length; i++) {
142 |       n.matrix[i][0] = arr[i];
143 |     }
144 |     return n;
145 |   }
146 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
147 |   //sets this matrix from an array
148 |   void fromArray(float[] arr) {
149 |     for (int i = 0; i< rows; i++) {
150 |       for (int j = 0; j< cols; j++) {
151 |         matrix[i][j] =  arr[j+i*cols];
152 |       }
153 |     }
154 |   }
155 | //---------------------------------------------------------------------------------------------------------------------------------------------------------    
156 |   //returns an array which represents this matrix
157 |   float[] toArray() {
158 |     float[] arr = new float[rows*cols];
159 |     for (int i = 0; i< rows; i++) {
160 |       for (int j = 0; j< cols; j++) {
161 |         arr[j+i*cols] = matrix[i][j];
162 |       }
163 |     }
164 |     return arr;
165 |   }
166 | 
167 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
168 |   //for ix1 matrixes adds one to the bottom
169 |   Matrix addBias() {
170 |     Matrix n = new Matrix(rows+1, 1);
171 |     for (int i =0; i<rows; i++) {
172 |       n.matrix[i][0] = matrix[i][0];
173 |     }
174 |     n.matrix[rows][0] = 1;
175 |     return n;
176 |   }
177 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
178 |   //applies the activation function(sigmoid) to each element of the matrix
179 |   Matrix activate() {
180 |     Matrix n = new Matrix(rows, cols);
181 |     for (int i =0; i<rows; i++) {
182 |       for (int j = 0; j<cols; j++) {
183 |         n.matrix[i][j] = sigmoid(matrix[i][j]);
184 |       }
185 |     }
186 |     return n;
187 |   }
188 |   
189 | //---------------------------------------------------------------------------------------------------------------------------------------------------------    
190 |   //sigmoid activation function
191 |   float sigmoid(float x) {
192 |     float y = 1 / (1 + pow((float)Math.E, -x));
193 |     return y;
194 |   }
195 |   //returns the matrix that is the derived sigmoid function of the current matrix
196 |   Matrix sigmoidDerived() {
197 |     Matrix n = new Matrix(rows, cols);
198 |     for (int i =0; i<rows; i++) {
199 |       for (int j = 0; j<cols; j++) {
200 |         n.matrix[i][j] = (matrix[i][j] * (1- matrix[i][j]));
201 |       }
202 |     }
203 |     return n;
204 |   }
205 | 
206 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
207 |   //returns the matrix which is this matrix with the bottom layer removed
208 |   Matrix removeBottomLayer() {
209 |     Matrix n = new Matrix(rows-1, cols);      
210 |     for (int i =0; i<n.rows; i++) {
211 |       for (int j = 0; j<cols; j++) {
212 |         n.matrix[i][j] = matrix[i][j];
213 |       }
214 |     }
215 |     return n;
216 |   }
217 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
218 |   //Mutation function for genetic algorithm 
219 |   
220 |   void mutate(float mutationRate) {
221 |     
222 |     //for each element in the matrix
223 |     for (int i =0; i<rows; i++) {
224 |       for (int j = 0; j<cols; j++) {
225 |         float rand = random(1);
226 |         if (rand<mutationRate) {//if chosen to be mutated
227 |           matrix[i][j] += randomGaussian()/5;//add a random value to it(can be negative)
228 |           
229 |           //set the boundaries to 1 and -1
230 |           if (matrix[i][j]>1) {
231 |             matrix[i][j] = 1;
232 |           }
233 |           if (matrix[i][j] <-1) {
234 |             matrix[i][j] = -1;
235 |           }
236 |         }
237 |       }
238 |     }
239 |   }
240 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
241 |   //returns a matrix which has a random number of values from this matrix and the rest from the parameter matrix
242 |   Matrix crossover(Matrix partner) {
243 |     Matrix child = new Matrix(rows, cols);
244 |     
245 |     //pick a random point in the matrix
246 |     int randC = floor(random(cols));
247 |     int randR = floor(random(rows));
248 |     for (int i =0; i<rows; i++) {
249 |       for (int j = 0; j<cols; j++) {
250 | 
251 |         if ((i< randR)|| (i==randR && j<=randC)) { //if before the random point then copy from this matric
252 |           child.matrix[i][j] = matrix[i][j];
253 |         } else { //if after the random point then copy from the parameter array
254 |           child.matrix[i][j] = partner.matrix[i][j];
255 |         }
256 |       }
257 |     }
258 |     return child;
259 |   }
260 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
261 |   //return a copy of this matrix
262 |   Matrix clone() {
263 |     Matrix clone = new  Matrix(rows, cols);
264 |     for (int i =0; i<rows; i++) {
265 |       for (int j = 0; j<cols; j++) {
266 |         clone.matrix[i][j] = matrix[i][j];
267 |       }
268 |     }
269 |     return clone;
270 |   }
271 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/NeuralNet.pde:
--------------------------------------------------------------------------------
  1 | class NeuralNet {
  2 | 
  3 |   int iNodes;//No. of input nodes
  4 |   int hNodes;//No. of hidden nodes
  5 |   int oNodes;//No. of output nodes
  6 | 
  7 |   Matrix whi;//matrix containing weights between the input nodes and the hidden nodes
  8 |   Matrix whh;//matrix containing weights between the hidden nodes and the second layer hidden nodes
  9 |   Matrix woh;//matrix containing weights between the second hidden layer nodes and the output nodes
 10 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 11 | 
 12 |   //constructor
 13 |   NeuralNet(int inputs, int hiddenNo, int outputNo) {
 14 | 
 15 |     //set dimensions from parameters
 16 |     iNodes = inputs;
 17 |     oNodes = outputNo;
 18 |     hNodes = hiddenNo;
 19 | 
 20 | 
 21 |     //create first layer weights 
 22 |     //included bias weight
 23 |     whi = new Matrix(hNodes, iNodes +1);
 24 | 
 25 |     //create second layer weights
 26 |     //include bias weight
 27 |     whh = new Matrix(hNodes, hNodes +1);
 28 | 
 29 |     //create second layer weights
 30 |     //include bias weight
 31 |     woh = new Matrix(oNodes, hNodes +1);  
 32 | 
 33 |     //set the matricies to random values
 34 |     whi.randomize();
 35 |     whh.randomize();
 36 |     woh.randomize();
 37 |   }
 38 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 39 | 
 40 |   //mutation function for genetic algorithm
 41 |   void mutate(float mr) {
 42 |     //mutates each weight matrix
 43 |     whi.mutate(mr);
 44 |     whh.mutate(mr);
 45 |     woh.mutate(mr);
 46 |   }
 47 | 
 48 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 49 |   //calculate the output values by feeding forward through the neural network
 50 |   float[] output(float[] inputsArr) {
 51 | 
 52 |     //convert array to matrix
 53 |     //Note woh has nothing to do with it its just a function in the Matrix class
 54 |     Matrix inputs = woh.singleColumnMatrixFromArray(inputsArr);
 55 | 
 56 |     //add bias 
 57 |     Matrix inputsBias = inputs.addBias();
 58 | 
 59 | 
 60 |     //-----------------------calculate the guessed output
 61 | 
 62 |     //apply layer one weights to the inputs
 63 |     Matrix hiddenInputs = whi.dot(inputsBias);
 64 | 
 65 |     //pass through activation function(sigmoid)
 66 |     Matrix hiddenOutputs = hiddenInputs.activate();
 67 | 
 68 |     //add bias
 69 |     Matrix hiddenOutputsBias = hiddenOutputs.addBias();
 70 | 
 71 |     //apply layer two weights
 72 |     Matrix hiddenInputs2 = whh.dot(hiddenOutputsBias);
 73 |     Matrix hiddenOutputs2 = hiddenInputs2.activate();
 74 |     Matrix hiddenOutputsBias2 = hiddenOutputs2.addBias();
 75 | 
 76 |     //apply level three weights
 77 |     Matrix outputInputs = woh.dot(hiddenOutputsBias2);
 78 |     //pass through activation function(sigmoid)
 79 |     Matrix outputs = outputInputs.activate();
 80 | 
 81 |     //convert to an array and return
 82 |     return outputs.toArray();
 83 |   }
 84 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 85 |   //crossover function for genetic algorithm
 86 |   NeuralNet crossover(NeuralNet partner) {
 87 | 
 88 |     //creates a new child with layer matrices from both parents
 89 |     NeuralNet child = new NeuralNet(iNodes, hNodes, oNodes);
 90 |     child.whi = whi.crossover(partner.whi);
 91 |     child.whh = whh.crossover(partner.whh);
 92 |     child.woh = woh.crossover(partner.woh);
 93 |     return child;
 94 |   }
 95 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 96 |   //return a neural net which is a clone of this Neural net
 97 |   NeuralNet clone() {
 98 |     NeuralNet clone  = new NeuralNet(iNodes, hNodes, oNodes); 
 99 |     clone.whi = whi.clone();
100 |     clone.whh = whh.clone();
101 |     clone.woh = woh.clone();
102 | 
103 |     return clone;
104 |   }
105 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
106 |   //converts the weights matrices to a single table 
107 |   //used for storing the snakes brain in a file
108 |   Table NetToTable() {
109 | 
110 |     //create table
111 |     Table t = new Table();
112 | 
113 | 
114 |     //convert the matricies to an array 
115 |     float[] whiArr = whi.toArray();
116 |     float[] whhArr = whh.toArray();
117 |     float[] wohArr = woh.toArray();
118 | 
119 |     //set the amount of columns in the table
120 |     for (int i = 0; i< max(whiArr.length, whhArr.length, wohArr.length); i++) {
121 |       t.addColumn();
122 |     }
123 | 
124 |     //set the first row as whi
125 |     TableRow tr = t.addRow();
126 | 
127 |     for (int i = 0; i< whiArr.length; i++) {
128 |       tr.setFloat(i, whiArr[i]);
129 |     }
130 | 
131 | 
132 |     //set the second row as whh
133 |     tr = t.addRow();
134 | 
135 |     for (int i = 0; i< whhArr.length; i++) {
136 |       tr.setFloat(i, whhArr[i]);
137 |     }
138 | 
139 |     //set the third row as woh
140 |     tr = t.addRow();
141 | 
142 |     for (int i = 0; i< wohArr.length; i++) {
143 |       tr.setFloat(i, wohArr[i]);
144 |     }
145 | 
146 |     //return table
147 |     return t;
148 |   }
149 | 
150 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
151 |   //takes in table as parameter and overwrites the matrices data for this neural network
152 |   //used to load snakes from file
153 |   void TableToNet(Table t) {
154 | 
155 |     //create arrays to tempurarily store the data for each matrix
156 |     float[] whiArr = new float[whi.rows * whi.cols];
157 |     float[] whhArr = new float[whh.rows * whh.cols];
158 |     float[] wohArr = new float[woh.rows * woh.cols];
159 | 
160 |     //set the whi array as the first row of the table
161 |     TableRow tr = t.getRow(0);
162 | 
163 |     for (int i = 0; i< whiArr.length; i++) {
164 |       whiArr[i] = tr.getFloat(i);
165 |     }
166 | 
167 | 
168 |     //set the whh array as the second row of the table
169 |     tr = t.getRow(1);
170 | 
171 |     for (int i = 0; i< whhArr.length; i++) {
172 |       whhArr[i] = tr.getFloat(i);
173 |     }
174 | 
175 |     //set the woh array as the third row of the table
176 | 
177 |     tr = t.getRow(2);
178 | 
179 |     for (int i = 0; i< wohArr.length; i++) {
180 |       wohArr[i] = tr.getFloat(i);
181 |     }
182 | 
183 | 
184 |     //convert the arrays to matrices and set them as the layer matrices 
185 |     whi.fromArray(whiArr);
186 |     whh.fromArray(whhArr);
187 |     woh.fromArray(wohArr);
188 |   }
189 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/Population.pde:
--------------------------------------------------------------------------------
  1 | class Population {
  2 |   
  3 |   Snake[] snakes;//all the snakes in the population
  4 | 
  5 |   int gen = 1;//which generation we are up to 
  6 |   int globalBest = 4;// the best score ever achieved by this population
  7 |   long globalBestFitness = 0; // the best fitness ever achieved by this population
  8 |   int currentBest = 4;//the current best score
  9 |   int currentBestSnake = 0; //the position of the current best snake (highest score) in the array
 10 | 
 11 |   Snake globalBestSnake; //a clone of the best snake this population has ever seen
 12 |   
 13 |   int populationID = floor(random(10000)); // a random number to identify the population, used for saving snakes
 14 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 15 |   //constructor
 16 |   Population(int size) {
 17 |     snakes = new Snake[size];
 18 |     //initiate all the snakes
 19 |     for (int i =0; i<snakes.length; i++) {
 20 |       snakes[i] = new Snake();
 21 |     }
 22 |     globalBestSnake = snakes[0].clone();
 23 | 
 24 |   }
 25 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 26 |   
 27 |   //used to help improve legends 
 28 |   Population(int size, Snake best) {
 29 |     
 30 |     
 31 |     snakes = new Snake[size];
 32 |     
 33 |     //set all the snakes as mutated clones of the legend snake
 34 |     for (int i =0; i<snakes.length; i++) {
 35 |       snakes[i] = best.clone();
 36 |       snakes[i].mutate(globalMutationRate);
 37 |     }
 38 |     
 39 |     globalBestSnake = best.clone();
 40 | 
 41 |   }
 42 |   
 43 |   
 44 |    //used to help improve legends 
 45 |   Population(Snake best) {
 46 |     
 47 |     
 48 |     snakes = new Snake[2000];
 49 |     
 50 |     //set all the snakes as  the legend snake
 51 |     for (int i =0; i<snakes.length; i++) {
 52 |       snakes[i] = best.clone();
 53 |       snakes[i].test = true;
 54 |     }
 55 |     
 56 |     //globalBestSnake = best.clone();
 57 | 
 58 |   }
 59 |    
 60 |   
 61 | //---------------------------------------------------------------------------------------------------------------------------------------------------------    
 62 |   //updates all the snakes in the population which are currently alive
 63 |   void updateAlive() {
 64 |     for (int i = 0; i< snakes.length; i++) {
 65 |       if (snakes[i].alive) {
 66 |         snakes[i].look(); //get inputs for brain
 67 |         snakes[i].setVelocity();  //get outputs from the neural net
 68 |         snakes[i].move(); //move the snake in the direction indicated by the neural net
 69 |         if (snakes[i].alive && (showAll || (i == currentBestSnake)))//if still alive show the snake
 70 |         {
 71 |           snakes[i].show();
 72 |         }
 73 |       }
 74 |     }
 75 |     setCurrentBest(); //after updating every snake renew the best snake
 76 |   }
 77 | //---------------------------------------------------------------------------------------------------------------------------------------------------------    
 78 |   //test if all the snakes in this population are dead
 79 |   boolean done() {
 80 |     for (int i = 0; i< snakes.length; i++) {
 81 |       if (snakes[i].alive) {
 82 |         return false;
 83 |       }
 84 |     }
 85 | 
 86 |     return true;
 87 |   }
 88 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 89 |   //calculates fitness of every snake
 90 |   void calcFitness() {
 91 |     for (int i = 0; i< snakes.length; i++) {
 92 | 
 93 |       snakes[i].calcFitness();
 94 |     }
 95 |   }
 96 |   
 97 |  //---------------------------------------------------------------------------------------------------------------------------------------------------------   
 98 |   //creates the next generation of snakes by natural selection
 99 |   void naturalSelection() {
100 | 
101 |     Snake[] newSnakes = new Snake[snakes.length]; //next generation of snakes
102 |     
103 |     //set the first snake as the best snake without crossover or mutation
104 |     setBestSnake();
105 |     newSnakes[0] = globalBestSnake.clone();
106 |     for (int i = 1; i<newSnakes.length; i++) {
107 |       
108 |       //select 2 parents based on fitness
109 |       Snake parent1 = selectSnake();
110 |       Snake parent2 = selectSnake();
111 |       
112 |       //crossover the 2 snakes to create the child
113 |       Snake child = parent1.crossover(parent2);
114 |       //mutate the child (weird thing to type)
115 |       child.mutate(globalMutationRate);
116 |       //add the child to the next generation
117 |       newSnakes[i] = child;
118 |       
119 |       //newSnakes[i] = selectSnake().clone().mutate(globalMutationRate); //uncomment this line to do natural selection without crossover
120 |     }
121 |     snakes = newSnakes.clone();// set the current generation to the next generation
122 |     
123 |     
124 |     gen+=1;
125 |     currentBest = 4;
126 |   }
127 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
128 |   //chooses snake from the population to return randomly(considering fitness)
129 |   Snake selectSnake() {
130 |     //this function works by randomly choosing a value between 0 and the sum of all the fitnesses
131 |     //then go through all the snakes and add their fitness to a running sum and if that sum is greater than the random value generated that snake is chosen
132 |     //since snakes with a higher fitness function add more to the running sum then they have a higher chance of being chosen
133 |     
134 |     
135 |     //calculate the sum of all the fitnesses
136 |     long fitnessSum = 0;
137 |     for (int i =0; i<snakes.length; i++) {
138 |       fitnessSum += snakes[i].fitness;
139 |     }
140 | 
141 |     
142 |     //set random value
143 |     long rand = floor(random(fitnessSum));
144 |     
145 |     //initialise the running sum
146 |     long runningSum = 0;
147 | 
148 |     for (int i = 0; i< snakes.length; i++) {
149 |       runningSum += snakes[i].fitness; 
150 |       if (runningSum > rand) {
151 |         return snakes[i];
152 |       }
153 |     }
154 |     //unreachable code to make the parser happy
155 |     return snakes[0];
156 |   }
157 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
158 |   //sets the best snakes globally and for this gen
159 |   void setBestSnake() {
160 |     //calculate max fitness
161 |     long max =0;
162 |     int maxIndex = 0;
163 |     for (int i =0; i<snakes.length; i++) {
164 |       if (snakes[i].fitness > max) {
165 |         max = snakes[i].fitness;
166 |         maxIndex = i;
167 |       }
168 |     }
169 |     //if best this gen is better than the global best then set the global best as the best this gen
170 |     if(max > globalBestFitness){
171 |       globalBestFitness = max;
172 |       globalBestSnake = snakes[maxIndex].clone();
173 |     }
174 |     
175 |     
176 |   }
177 |     
178 |  //---------------------------------------------------------------------------------------------------------------------------------------------------------   
179 |   //mutates all the snakes
180 |   void mutate() {
181 |     for (int i =1; i<snakes.length; i++) {
182 |       snakes[i].mutate(globalMutationRate);
183 |     }
184 |   }
185 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
186 |   //sets the current best snake, used when just showing one snake at a time
187 |   void setCurrentBest() {
188 |     if (!done()) {//if any snakes alive
189 |       float max =0;
190 |       int maxIndex = 0;
191 |       for (int i =0; i<snakes.length; i++) {
192 |         if (snakes[i].alive && snakes[i].len > max) {
193 |           max = snakes[i].len;
194 |           maxIndex = i;
195 |         }
196 |       }
197 | 
198 |       if (max > currentBest) {
199 |         currentBest = floor(max);
200 |       }
201 | 
202 |       //if the best length is more than 1 greater than the 5 stored in currentBest snake then set it;
203 |       //the + 5 is to stop the current best snake from jumping from snake to snake
204 |       if (!snakes[currentBestSnake].alive || max > snakes[currentBestSnake].len +5   ) {
205 | 
206 |         currentBestSnake  = maxIndex;
207 |       }
208 | 
209 |       
210 |       if (currentBest > globalBest) {
211 |         globalBest = currentBest;
212 |       }
213 |     }
214 |   }
215 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/SmartSnakesCombine.pde:
--------------------------------------------------------------------------------
  1 | //GLOBAL VARIABLES
  2 | import java.io.File;
  3 | World world;//world which stores the species / populations
  4 | 
  5 | World worldOfLegends;//world containing the legends, used for training the legends to be even better
  6 | 
  7 | 
  8 | int speed = 30;//the frame rate
  9 | 
 10 | //booleans used to control the game state
 11 | boolean showAll = true;//whether to show all the snakes in the generation or just the current best snake
 12 | boolean trainLegendSnakes = false; //true if training the legends i.e. if running worldOfLegends
 13 | boolean showingLegend = false;//true if testing just one legend
 14 | boolean fusionGo =false;//true if testing the snake fusion 
 15 | 
 16 | float globalMutationRate = 0.01;
 17 | 
 18 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 19 | //run on startup
 20 | void setup() {
 21 |   frameRate(speed);
 22 |   size(800, 500);
 23 |   world = new World(5, 2000);
 24 | }
 25 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 26 | void draw() {
 27 |   background(40);
 28 | 
 29 |   drawData();
 30 |   
 31 |   //training/evolving the legend snakes
 32 |   if (trainLegendSnakes) {
 33 |     if (!worldOfLegends.done()) {
 34 |       worldOfLegends.updateAlive();
 35 |     } else {
 36 |       //all are dead
 37 |       worldOfLegends.geneticAlgorithm();
 38 |     }
 39 | 
 40 |     //testing a single legend
 41 |   } else if (showingLegend) {
 42 |     if (world.legend.alive) {
 43 |       world.updateLegend();
 44 |     } else {
 45 |       if(world.legend.len < 100){
 46 |         
 47 |         world.playLegend(world.legendNo);
 48 |       }else{
 49 | 
 50 |       showingLegend = false;
 51 |       }
 52 |     }
 53 | 
 54 |     // testing the supersnake fusion
 55 |   } else if (fusionGo) {
 56 |     if (world.fusedSnake.alive) {
 57 |       world.updateSuperSnake();
 58 |     } else { //once done set the fusionGo to false
 59 |       fusionGo = false;
 60 |     }
 61 | 
 62 | 
 63 |     //training/evolving population normally
 64 |   } else {
 65 |     if (!world.done()) {//if there is still a snake alive then update them
 66 |       world.updateAlive();
 67 |     } else {//if all are dead :(
 68 |       world.geneticAlgorithm();
 69 |     }
 70 |   }
 71 | }
 72 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 73 | 
 74 | void keyPressed() {
 75 |   switch(key) {
 76 |   case ' '://toggle show all
 77 |     showAll = !showAll;
 78 |     break;
 79 |   case '+'://speed up frame rate
 80 |     speed += 10;
 81 |     frameRate(speed);
 82 |     break;
 83 |   case '-'://slow down frame rate
 84 |     if (speed > 10) {
 85 |       speed -= 10;
 86 |       frameRate(speed);
 87 |     }
 88 |     break;
 89 |   case 'f'://create a fused snake from the legends
 90 |     fusionGo  = true;
 91 |     world.snakeFusion();
 92 |     break;
 93 |   case '0'://test legend 0
 94 |     showingLegend = true;
 95 |     world.playLegend(0);
 96 |     break;
 97 |   case '1': // test legend no 1
 98 |     world.playLegend(1);
 99 |     showingLegend = true;
100 |     break;
101 |   case '2'://test legend no 2
102 |     world.playLegend(2);
103 |     showingLegend = true;
104 |     break;
105 |   case '3'://test legend no 3
106 |     world.playLegend(3);
107 |     showingLegend = true;
108 |     break;
109 |   case '4'://test legend no 4
110 |     world.playLegend(4);
111 |     showingLegend = true;
112 |     break;
113 |   case 'h'://halve the mutation rate
114 |     globalMutationRate /=2;
115 |     break;
116 |   case 'd'://double the mutation rate
117 |     globalMutationRate *= 2;
118 |     break;
119 |   case 'l'://train the legends
120 |     trainLegendSnakes =!trainLegendSnakes;
121 |     if (trainLegendSnakes == true) {//load best snakes from file and setup worldOfLegends
122 |       world.loadBestSnakes();
123 |       worldOfLegends = new World(1000, world.SnakesOfLegend);
124 |     }
125 | 
126 |     
127 |   }
128 | }
129 | 
130 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
131 | void drawData() {
132 |   fill(255);
133 |   stroke(255);
134 |   line(400, 0, 400, 400);
135 |   line(0, 400, 800, 400);
136 |   textSize(30);
137 | 
138 |   //training/evolving the legend snakes
139 |   if (trainLegendSnakes) {
140 |     text("Generation: " + (worldOfLegends.gen), 10, 100); 
141 |     text("Speed: " + speed, 10, 150);
142 |     text("Global Best: " + (worldOfLegends.worldBestScore), 10, 200);
143 |     text("mutation Rate: " + globalMutationRate, 10, 250);      
144 | 
145 |     //testing a single legend
146 |   } else if (showingLegend) {
147 |     text("Score: " + (world.legend.len-4), 10, 100); 
148 | 
149 |     // testing the supersnake fusion
150 |   } else if (fusionGo) {
151 |     text("Score: " + (world.fusedSnake.len-4), 10, 100); 
152 | 
153 |     //training/evolving population normally
154 |   } else {
155 | 
156 |     text("Generation: " + (world.gen), 10, 100); 
157 |     text("Speed: " + speed, 10, 150);
158 |     text("Global Best: " + (world.worldBestScore), 10, 200);
159 |     text("mutation Rate: " + globalMutationRate, 10, 250);
160 |   }
161 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/Snake.pde:
--------------------------------------------------------------------------------
  1 | class Snake {
  2 | 
  3 |   int len = 1;//the length of the snake
  4 |   PVector pos;//position of the head of the snake
  5 |   ArrayList<PVector> tailPositions; //all the positions of the tail of the snake
  6 |   PVector vel;//the velocity of the snake i.e. direction it will move next
  7 |   PVector temp; //just a temporary PVector which gets used a bunch
  8 |   Food food;//the food that this snake needs to eat
  9 |   NeuralNet brain; // the neural net controlling the snake
 10 |   float[] vision = new float[24]; //the inputs for the neural net
 11 |   float[] decision; // the output of the neural net
 12 | 
 13 |   int lifetime = 0;//how long the snake lived for
 14 |   long fitness = 0;//the quality of this snake
 15 |   int leftToLive = 200; //the number of moves left to live if this gets down to 0 the snake dies
 16 |   //this is to prevent the snakes doing circles forever
 17 | 
 18 |   
 19 |   int growCount = 0;//the amount the snake still needs to grow
 20 | 
 21 |   boolean alive = true;  //true if the snake is alive
 22 |   boolean test = false;//true if the snake is being tested not trained
 23 | 
 24 | 
 25 | 
 26 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 27 | 
 28 |   //constructor
 29 |   Snake() {
 30 |     //set initial position of head and add 3 tail positions since the starting length is 4
 31 |     int x = 600;
 32 |     int y = 200;
 33 |     pos = new PVector(x, y);
 34 |     vel = new PVector(10, 0);
 35 |     tailPositions = new ArrayList<PVector>();
 36 |     temp = new PVector(x-30, y);
 37 |     tailPositions.add(temp);
 38 |     temp = new PVector(x-20, y);
 39 |     tailPositions.add(temp);
 40 |     temp = new PVector(x-10, y);
 41 |     tailPositions.add(temp);
 42 |     len+=3;
 43 | 
 44 |     //intiate the food
 45 |     food = new Food();
 46 | 
 47 | 
 48 | 
 49 | 
 50 |     brain = new NeuralNet(24, 18, 4);//create a neural net with 24 input neurons 18 hidden neurons and 4 output neurons
 51 |     leftToLive = 200;
 52 |   }
 53 | 
 54 |   //mutates neural net
 55 |   void mutate(float mr) {
 56 |     brain.mutate(mr);
 57 |   }
 58 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 59 | 
 60 |   //set the velocity from the output of the neural network
 61 |   void setVelocity() {
 62 |     //get the output of the neural network
 63 |     decision = brain.output(vision);
 64 | 
 65 |     //get the maximum position in the output array and use this as the decision on which direction to go
 66 |     float max = 0;
 67 |     int maxIndex  =0;
 68 |     for (int i = 0; i < decision.length; i++) {
 69 |       if (max < decision[i]) {
 70 |         max = decision[i];
 71 |         maxIndex = i;
 72 |       }
 73 |     }
 74 |     //set the velocity based on this decision
 75 |     if (maxIndex == 0) {
 76 |       //if (vel.x!=10 && vel.y !=0) { //this is to stop the snake from going back into its own body but i removed it to teach the snakes to avoid their bodies
 77 |       vel.x =-10;
 78 |       vel.y =0;
 79 |       //}
 80 |     } else if (maxIndex == 1) {
 81 |       //if (vel.x!=0 && vel.y !=10) {
 82 |       vel.x =0;
 83 |       vel.y =-10;
 84 |       //}
 85 |     } else if (maxIndex == 2) {
 86 |       //if (vel.x!=-10 && vel.y !=0) {
 87 |       vel.x =10;
 88 |       vel.y =0;
 89 |       //}
 90 |     } else {
 91 |       //if (vel.x!=0 && vel.y !=-10) {
 92 |       vel.x =0;
 93 |       vel.y =10;
 94 |       //}
 95 |     }
 96 |   }
 97 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 98 | 
 99 |   //move the snake in direction of the vel PVector
100 |   void move() {
101 |     //move through time
102 |     lifetime+=1;
103 |     leftToLive -=1;
104 | 
105 |     //if time left to live is up then kill the snake
106 |     if (leftToLive < 0) {
107 |       alive = false;
108 |     }
109 | 
110 |     //if the snake hit itself or the edge then kill it
111 |     if (gonnaDie(pos.x + vel.x, pos.y + vel.y)) {
112 |       alive= false;
113 |     }
114 | 
115 |     //if the snake is on  the same position as the food then eat it
116 |     if (pos.x + vel.x == food.pos.x && pos.y + vel.y == food.pos.y) {
117 |       eat();
118 |     }
119 | 
120 |     //snake grows 1 square at a time so if the snake has recently eaten then grow count will be greater than 0
121 |     if (growCount > 0) {
122 |       growCount --;
123 |       grow();
124 |     } else {//not growing then move all the tail positions to follow the head
125 |       for (int i = 0; i< tailPositions.size() -1; i++) {
126 |         temp = new PVector(tailPositions.get(i+1).x, tailPositions.get(i+1).y);
127 |         tailPositions.set(i, temp);
128 |       }
129 |       temp = new PVector(pos.x, pos.y);
130 |       tailPositions.set(len-2, temp);
131 |     }
132 | 
133 |     //actually move the snakes head
134 |     pos.add(vel);
135 |   }
136 | 
137 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
138 | 
139 |   //the snake just ate some food 
140 |   void eat() {
141 | 
142 |     //reset food to a new position  
143 |     food = new Food(); 
144 |     while (tailPositions.contains(food.pos)) { //make sure the food isnt on the snake
145 |       food = new Food();
146 |     }
147 |    
148 |     //increase time left to live
149 |     leftToLive += 100;
150 | 
151 |     //if testing then grow by 4 but if not and the snake is still small only grow by 1
152 |     //this is for helping snakes evolving so they dont get too big too soon
153 |     if (test||len>=10) {
154 |       growCount += 4;
155 |     } else {
156 |       growCount += 1;
157 |     }
158 |   }
159 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
160 | 
161 |   //display the snake
162 |   void show() {
163 |     fill(255);
164 |     stroke(0);
165 |     //show the tail
166 |     for (int i = 0; i< tailPositions.size(); i++) {
167 |       rect(tailPositions.get(i).x, tailPositions.get(i).y, 10, 10);
168 |     }
169 |     //show the head
170 |     rect(pos.x, pos.y, 10, 10);
171 | 
172 |     //show the food
173 |     food.show();
174 |   }
175 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
176 | 
177 |   //grows the snake by 1 square
178 |   void grow() {
179 |     //add the head to the tail list this simulates the snake growing as the head is the only thing which moves
180 |     temp = new PVector(pos.x, pos.y);
181 |     tailPositions.add(temp);
182 |     len +=1;
183 |   }
184 | 
185 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
186 |   //returns true if the snake is going to hit itself or a wall
187 |   boolean gonnaDie(float x, float y) {
188 |     //check if hit wall
189 |     if (x < 400 || y < 0 || x >= 800 || y >= 400) {
190 |       return true;
191 |     }
192 | 
193 |     //check if hit tail
194 |     return isOnTail(x, y);
195 |   }
196 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------    
197 |   //returns true if the coordinates is on the snakes tail
198 |   boolean isOnTail(float x, float y) {
199 |     for (int i = 0; i < tailPositions.size(); i++) {
200 |       if (x == tailPositions.get(i).x &&  y == tailPositions.get(i).y) {
201 |         return true;
202 |       }
203 |     }
204 | 
205 |     return false;
206 |   }
207 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
208 | 
209 |   //calculate the fitness of the snake after it has died
210 |   void calcFitness() {
211 |     //fitness is based on length and lifetime
212 |     if (len < 10) {
213 |       fitness = floor(lifetime *lifetime * pow(2, (floor(len))));
214 |     } else {
215 |       //grows slower after 10 to stop fitness from getting stupidly big
216 |       //ensure greater than len = 9
217 |       fitness =  lifetime * lifetime;
218 |       fitness *= pow(2, 10);
219 |       fitness *=(len-9);
220 |     }
221 |   }
222 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
223 | 
224 |   //crossover function for genetic algorithm
225 |   Snake crossover(Snake partner) {
226 |     Snake child = new Snake();
227 | 
228 |     child.brain = brain.crossover(partner.brain);
229 |     return child;
230 |   }
231 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
232 | 
233 |   //returns a clone of the snake
234 |   Snake clone() {
235 |     Snake clone = new Snake();
236 |     clone.brain = brain.clone();
237 |     clone.alive = true;
238 |     return clone;
239 |   }
240 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
241 | 
242 |   //saves the snake to a file by converting it to a table
243 |   void saveSnake(int snakeNo, int score, int popID) {
244 |     //save the snakes top score and its population id 
245 |     Table snakeStats = new Table();
246 |     snakeStats.addColumn("Top Score");
247 |     snakeStats.addColumn("PopulationID");
248 |     TableRow tr = snakeStats.addRow();
249 |     tr.setFloat(0, score);
250 |     tr.setInt(1, popID);
251 | 
252 |     saveTable(snakeStats, "data/SnakeStats" + snakeNo+ ".csv");
253 | 
254 |     //save snakes brain
255 |     saveTable(brain.NetToTable(), "data/Snake" + snakeNo+ ".csv");
256 |   }
257 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
258 | 
259 |   //return the snake saved in the parameter position
260 |   Snake loadSnake(int snakeNo) {
261 | 
262 |     Snake load = new Snake();
263 |     Table t = loadTable("data/Snake" + snakeNo + ".csv");
264 |     load.brain.TableToNet(t);
265 |     return load;
266 |   }
267 | 
268 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
269 | 
270 |   //looks in 8 directions to find food,walls and its tail
271 |   void look() {
272 |     vision = new float[24];
273 |     //look left
274 |     float[] tempValues = lookInDirection(new PVector(-10, 0));
275 |     vision[0] = tempValues[0];
276 |     vision[1] = tempValues[1];
277 |     vision[2] = tempValues[2];
278 |     //look left/up  
279 |     tempValues = lookInDirection(new PVector(-10, -10));
280 |     vision[3] = tempValues[0];
281 |     vision[4] = tempValues[1];
282 |     vision[5] = tempValues[2];
283 |     //look up
284 |     tempValues = lookInDirection(new PVector(0, -10));
285 |     vision[6] = tempValues[0];
286 |     vision[7] = tempValues[1];
287 |     vision[8] = tempValues[2];
288 |     //look up/right
289 |     tempValues = lookInDirection(new PVector(10, -10));
290 |     vision[9] = tempValues[0];
291 |     vision[10] = tempValues[1];
292 |     vision[11] = tempValues[2];
293 |     //look right
294 |     tempValues = lookInDirection(new PVector(10, 0));
295 |     vision[12] = tempValues[0];
296 |     vision[13] = tempValues[1];
297 |     vision[14] = tempValues[2];
298 |     //look right/down
299 |     tempValues = lookInDirection(new PVector(10, 10));
300 |     vision[15] = tempValues[0];
301 |     vision[16] = tempValues[1];
302 |     vision[17] = tempValues[2];
303 |     //look down
304 |     tempValues = lookInDirection(new PVector(0, 10));
305 |     vision[18] = tempValues[0];
306 |     vision[19] = tempValues[1];
307 |     vision[20] = tempValues[2];
308 |     //look down/left
309 |     tempValues = lookInDirection(new PVector(-10, 10));
310 |     vision[21] = tempValues[0];
311 |     vision[22] = tempValues[1];
312 |     vision[23] = tempValues[2];
313 |   }
314 | 
315 | 
316 |   float[] lookInDirection(PVector direction) {
317 |     //set up a temp array to hold the values that are going to be passed to the main vision array
318 |     float[] visionInDirection = new float[3];
319 | 
320 |     PVector position = new PVector(pos.x, pos.y);//the position where we are currently looking for food or tail or wall
321 |     boolean foodIsFound = false;//true if the food has been located in the direction looked
322 |     boolean tailIsFound = false;//true if the tail has been located in the direction looked 
323 |     float distance = 0;
324 |     //move once in the desired direction before starting 
325 |     position.add(direction);
326 |     distance +=1;
327 | 
328 |     //look in the direction until you reach a wall
329 |     while (!(position.x < 400 || position.y < 0 || position.x >= 800 || position.y >= 400)) {
330 | 
331 |       //check for food at the position
332 |       if (!foodIsFound && position.x == food.pos.x && position.y == food.pos.y) {
333 |         visionInDirection[0] = 1;
334 |         foodIsFound = true; // dont check if food is already found
335 |       }
336 | 
337 |       //check for tail at the position
338 |       if (!tailIsFound && isOnTail(position.x, position.y)) {
339 |         visionInDirection[1] = 1/distance;
340 |         tailIsFound = true; // dont check if tail is already found
341 |       }
342 | 
343 |       //look further in the direction
344 |       position.add(direction);
345 |       distance +=1;
346 |     }
347 | 
348 |     //set the distance to the wall
349 |     visionInDirection[2] = 1/distance;
350 | 
351 |     return visionInDirection;
352 |   }
353 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/SuperSnake.pde:
--------------------------------------------------------------------------------
  1 | //a supersnake which is fusion of 5 best snakes
  2 | 
  3 | class SuperSnake {
  4 | 
  5 | 
  6 | 
  7 | 
  8 |   int len = 1;//the length of the snake
  9 |   PVector pos;//position of the head of the snake
 10 |   ArrayList<PVector> tailPositions; //all the positions of the tail of the snake
 11 |   PVector vel;//the velocity of the snake i.e. direction it will move next
 12 |   PVector temp; //just a temporary PVector which gets used a bunch
 13 |   Food food;//the food that this snake needs to eat
 14 | 
 15 |   float[] vision = new float[24]; //the inputs for the neural net
 16 |   float[] decision; // the output of the neural net
 17 | 
 18 |   int lifetime = 0;//how long the snake lived for
 19 |   long fitness = 0;//the quality of this snake
 20 |   int leftToLive = 500; //the number of moves left to live if this gets down to 0 the snake dies
 21 |   //this is to prevent the snakes doing circles forever
 22 | 
 23 | 
 24 | 
 25 |   int growCount = 0; //the amount the snake still needs to grow
 26 | 
 27 |   boolean alive = true;  //true if the snake is alive
 28 | 
 29 | 
 30 | 
 31 |   NeuralNet[] brain; // the array of neural nets controlling the snake
 32 | 
 33 |   SuperSnakeClone[] clones;
 34 | 
 35 |   int brainToFollow = 0;  //which brain to follow for the next few moves
 36 |   boolean foodFound = false;//true if a clone has found the food safely
 37 |   boolean sawFood = false; //true if a clone has seen the food
 38 |   int movesToFollow = 0;//how many moves to follow that snake
 39 | 
 40 | 
 41 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 42 | 
 43 |   //constructor
 44 |   SuperSnake(NeuralNet[] demBrains) {
 45 |     //set intial position of head and add 3 tail positions
 46 |     int x = 600;
 47 |     int y = 200;
 48 |     pos = new PVector(x, y);
 49 |     vel = new PVector(10, 0);
 50 |     tailPositions = new ArrayList<PVector>();
 51 |     temp = new PVector(x-30, y);
 52 |     tailPositions.add(temp);
 53 |     temp = new PVector(x-20, y);
 54 |     tailPositions.add(temp);
 55 |     temp = new PVector(x-10, y);
 56 |     tailPositions.add(temp);
 57 |     len+=3;
 58 | 
 59 |     food = new Food();
 60 |     
 61 | 
 62 |     brain = demBrains;
 63 | 
 64 |     clones = new SuperSnakeClone[demBrains.length];
 65 |   }
 66 | 
 67 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 68 | 
 69 |   //calculates the best direction to go based on the foresight from all of its brains 
 70 |   void bestDecision() {
 71 |     
 72 | 
 73 | 
 74 |     //for each brain create a clone and run it until it dies or is trapped or finds food
 75 |     for (int i = 0; i < brain.length; i++) {
 76 |       clones[i] = new SuperSnakeClone(this, brain[i]);
 77 |       clones[i].runClone();
 78 |       
 79 |     }
 80 |     
 81 |     //if any clones found the food find the one which does it in the least number of moves
 82 |     int min = 1000;
 83 |     int cloneAteFood = -1;
 84 |     for (int i = 0; i < brain.length; i++) {
 85 | 
 86 |       if (clones[i].foodFound) {
 87 |         if (clones[i].moveCount < min) {
 88 |           min =  clones[i].foodSeenAtCount;
 89 |           cloneAteFood = i;
 90 | 
 91 |         }
 92 |       }
 93 |     }
 94 |      //if any of the clones ate the food
 95 |     if (cloneAteFood != -1) {
 96 |       //set this clone as the brain to follow
 97 |       foodFound = true; 
 98 |       movesToFollow = clones[cloneAteFood].moveCount;
 99 |       brainToFollow = cloneAteFood;
100 |       return;//we are done
101 |     }
102 |     
103 | 
104 |     //if you get to this point then none of the snakes found the food so lets test for the next best 
105 |     //has any seen the food
106 | 
107 |      min = 1000;
108 |     int cloneSeenFood = -1;
109 |     for (int i = 0; i < brain.length; i++) {
110 | 
111 |       if (clones[i].seenFood) {
112 |         if (clones[i].foodSeenAtCount < min) {
113 |           min =  clones[i].foodSeenAtCount;
114 |           cloneSeenFood = i;
115 |         }
116 |       }
117 |     }
118 | 
119 |     //if any of the clones saw the food
120 |     if (cloneSeenFood != -1) {
121 |       sawFood = true; 
122 |       movesToFollow = clones[cloneSeenFood].foodSeenAtCount;
123 |       brainToFollow = cloneSeenFood;
124 |       return;
125 |     }
126 | 
127 | 
128 |     //if you get to this point then no snake found the food nor did they see the food, damn
129 |     //follow the snake which made it the furthest without running out of moves (because they would probably be looping)
130 | 
131 |     int max = 0;
132 |     int cloneLastedLongest = 0;
133 |     for (int i = 0; i < brain.length; i++) {
134 | 
135 |       if (!clones[i].ranOut) {
136 |         if (clones[i].moveCount > max) {
137 |           max =  clones[i].moveCount;
138 |           cloneLastedLongest = i;
139 |         }
140 |       }
141 |     }
142 | 
143 |     brainToFollow = cloneLastedLongest;
144 |     movesToFollow = 1;
145 |     return;
146 |   }
147 | 
148 | 
149 | 
150 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
151 | 
152 |   //from an output array returns an int indicating the direction the snake should go
153 |   int getDirection(float[] netOutputs) {
154 |     float max = 0;
155 |     int maxIndex = 0;
156 | 
157 |     for (int i = 0; i < netOutputs.length; i++) {
158 |       if (max < netOutputs[i]) {
159 |         max = netOutputs[i];
160 |         maxIndex = i;
161 |       }
162 |     }
163 |     return maxIndex;
164 |   }
165 | 
166 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
167 | 
168 |  
169 |   void setVelocity() {
170 |     look();
171 |     //if no more moves to follow then create clones to 'imagine' where to go
172 |     if (movesToFollow <= 0) {
173 |       sawFood = false;
174 |       foodFound = false;
175 |       bestDecision();
176 |     }
177 | 
178 |     //get the direction from the brain 
179 |     int direction  = getDirection(brain[brainToFollow].output(vision));
180 | 
181 |     //set the velocity based on this decision
182 |     switch(direction) {
183 |     case 0://left
184 |       vel = new PVector(-10, 0);
185 |       break;
186 |     case 1://up
187 |       vel = new PVector(0, -10);
188 |       break;
189 |     case 2://right
190 |       vel = new PVector(10, 0);
191 |       break;
192 |     case 3://down
193 |       vel = new PVector(0, 10);
194 |       break;
195 |     }
196 |   }
197 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
198 |   //move the snake in direction of the vel PVector
199 |   void move() {
200 |     lifetime+=1;
201 |     leftToLive -=1;
202 |     movesToFollow -=1;
203 |     
204 |     //if time left to live is up then kill the snake
205 |     if (leftToLive < 0) {
206 |       alive = false;
207 |       println("fuck1");
208 |     }
209 |     
210 |     //if the snake hit itself or the edge then kill it
211 |     if (gonnaDie(pos.x + vel.x, pos.y + vel.y)) {
212 |       alive= false;
213 |       println("fuck2");
214 | 
215 |     }
216 | 
217 |     //if the snake is on  the same position as the food then eat it
218 |     if (pos.x + vel.x == food.pos.x && pos.y + vel.y == food.pos.y) {
219 |       eat();
220 |     }
221 |     
222 |      //snake grows 1 square at a time so if the snake has recently eaten then grow count will be greater than 0
223 |     if (growCount > 0) {
224 |       growCount --;
225 |       grow();
226 |     } else {//not growing then move all the tail positions to follow the head
227 |       for (int i = 0; i< tailPositions.size() -1; i++) {
228 |         temp = new PVector(tailPositions.get(i+1).x, tailPositions.get(i+1).y);
229 |         tailPositions.set(i, temp);
230 |       }
231 | 
232 |       if (len>1) {
233 |         temp = new PVector(pos.x, pos.y);
234 |         tailPositions.set(len-2, temp);
235 |       }
236 |     }
237 | 
238 |     //actually move the head of the snake
239 |     pos.add(vel);
240 |   }
241 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
242 | //the snake just ate some food 
243 |   void eat() {
244 |     
245 |     //reset the food so its not on the tail
246 |     food = new Food(); 
247 |     while (tailPositions.contains(food.pos)) {
248 |       food = new Food();
249 |     }
250 | 
251 | 
252 |     //let the snake live longer
253 |     leftToLive += 100;
254 |     growCount +=4;//the snake grows by 4
255 |     movesToFollow =0;//make sure the bestDecision() function is called before the next move
256 |     foodFound = false;
257 |     
258 |   }
259 | 
260 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
261 | 
262 |   //show the super snake
263 |   void show() {
264 |     fill(255);
265 |     stroke(0);
266 |     //if a clone has found the food then show the snake as blue
267 |     if(foodFound){
268 |      fill(0,255,0); 
269 |     }else if(sawFood){
270 |      fill(0,0,255); 
271 |     }
272 |     
273 |     
274 |     for (int i = 0; i< tailPositions.size(); i++) {
275 |       rect(tailPositions.get(i).x, tailPositions.get(i).y, 10, 10);
276 |     }
277 |     rect(pos.x, pos.y, 10, 10);
278 |     food.show();
279 |   }
280 | 
281 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
282 |   //grows the snake by 1 square
283 |   void grow() {
284 |     //add the head to the tail list this simulates the snake growing as the head is the only thing which moves
285 |     temp = new PVector(pos.x, pos.y);
286 |     tailPositions.add(temp);
287 |     len +=1;
288 |   }
289 | 
290 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
291 |   //returns true if the snake is going to hit itself or a wall
292 |   boolean gonnaDie(float x, float y) {
293 |     //check if hit wall
294 |     if (x < 400 || y < 0 || x >= 800 || y >= 400) {
295 |       return true;
296 |     }
297 | 
298 |     //check if hit tail
299 |     return isOnTail(x, y);
300 |   }
301 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------    
302 |   //returns true if the coordinates is on the snakes tail
303 |   boolean isOnTail(float x, float y) {
304 |     for (int i = 0; i < tailPositions.size(); i++) {
305 |       if (x == tailPositions.get(i).x &&  y == tailPositions.get(i).y) {
306 |         return true;
307 |       }
308 |     }
309 | 
310 |     return false;
311 |   }
312 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
313 | 
314 |   //looks in 8 directions to find food,walls and its tail
315 |   void look() {
316 |     vision = new float[24];
317 |     //look left
318 |     float[] tempValues = lookInDirection(new PVector(-10, 0));
319 |     vision[0] = tempValues[0];
320 |     vision[1] = tempValues[1];
321 |     vision[2] = tempValues[2];
322 |     //look left/up  
323 |     tempValues = lookInDirection(new PVector(-10, -10));
324 |     vision[3] = tempValues[0];
325 |     vision[4] = tempValues[1];
326 |     vision[5] = tempValues[2];
327 |     //look up
328 |     tempValues = lookInDirection(new PVector(0, -10));
329 |     vision[6] = tempValues[0];
330 |     vision[7] = tempValues[1];
331 |     vision[8] = tempValues[2];
332 |     //look up/right
333 |     tempValues = lookInDirection(new PVector(10, -10));
334 |     vision[9] = tempValues[0];
335 |     vision[10] = tempValues[1];
336 |     vision[11] = tempValues[2];
337 |     //look right
338 |     tempValues = lookInDirection(new PVector(10, 0));
339 |     vision[12] = tempValues[0];
340 |     vision[13] = tempValues[1];
341 |     vision[14] = tempValues[2];
342 |     //look right/down
343 |     tempValues = lookInDirection(new PVector(10, 10));
344 |     vision[15] = tempValues[0];
345 |     vision[16] = tempValues[1];
346 |     vision[17] = tempValues[2];
347 |     //look down
348 |     tempValues = lookInDirection(new PVector(0, 10));
349 |     vision[18] = tempValues[0];
350 |     vision[19] = tempValues[1];
351 |     vision[20] = tempValues[2];
352 |     //look down/left
353 |     tempValues = lookInDirection(new PVector(-10, 10));
354 |     vision[21] = tempValues[0];
355 |     vision[22] = tempValues[1];
356 |     vision[23] = tempValues[2];
357 | 
358 | 
359 |   }
360 | 
361 | 
362 |   float[] lookInDirection(PVector direction) {
363 |     //set up a temp array to hold the values that are going to be passed to the main vision array
364 |     float[] visionInDirection = new float[3];
365 |     
366 |     PVector position = new PVector(pos.x, pos.y);//the position where we are currently looking for food or tail or wall
367 |     boolean foodIsFound = false;//true if the food has been located in the direction looked
368 |     boolean tailIsFound = false;//true if the tail has been located in the direction looked 
369 |     float distance = 0;
370 |     //move once in the desired direction before starting 
371 |     position.add(direction);
372 |     distance +=1;
373 | 
374 |     //look in the direction until you reach a wall
375 |     while (!(position.x < 400 || position.y < 0 || position.x >= 800 || position.y >= 400)) {
376 | 
377 |       //check for food at the position
378 |       if (!foodIsFound && position.x == food.pos.x && position.y == food.pos.y) {
379 |         visionInDirection[0] = 1;
380 |         foodIsFound = true; // dont check if food is already found
381 |       }
382 | 
383 |       //check for tail at the position
384 |       if (!tailIsFound && isOnTail(position.x, position.y)) {
385 |         visionInDirection[1] = 1/distance;
386 |         tailIsFound = true; // dont check if tail is already found
387 |       }
388 | 
389 |       //look further in the direction
390 |       position.add(direction);
391 |       distance +=1;
392 |     }
393 | 
394 |     //set the distance to the wall
395 |     visionInDirection[2] = 1/distance;
396 | 
397 |     return visionInDirection;
398 |   }
399 | 
400 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/SuperSnakeClone.pde:
--------------------------------------------------------------------------------
  1 | //a clone or thought which is used to plan ahead
  2 | 
  3 | class SuperSnakeClone {
  4 | 
  5 |   int len = 1;//the length of the snake
  6 |   PVector pos;//position of the head of the snake
  7 |   ArrayList<PVector> tailPositions; //all the positions of the tail of the snake
  8 |   PVector vel;//the velocity of the snake i.e. direction it will move next
  9 |   PVector temp; //just a temporary PVector which gets used a bunch
 10 |   Food food;//the food that this snake needs to eat
 11 |   NeuralNet brain; // the neural net controlling the snake
 12 |   float[] vision = new float[24]; //the inputs for the neural net
 13 |   float[] decision; // the output of the neural net
 14 |   ArrayList<PVector> blanks = new ArrayList<PVector>();//all the blank spaces that are enclosed by the snake used to tell if the snake is trapped 
 15 | 
 16 |   int leftToLive = 200; //the number of moves left ot live if this gets down to 0 the snake dies
 17 |   //this is to prevent the snakes doing circles forever
 18 | 
 19 | 
 20 |   int moveCount = 0;  //the amount of moves the clone has done
 21 |   boolean alive = true;  //true if the snake is alive
 22 |   boolean foodFound = false; // true if the snake found the food
 23 |   boolean trapped = false;//true if the snake is trapped
 24 | 
 25 | 
 26 |   boolean seenFood = false;//whether the snake saw the food
 27 |   int foodSeenAtCount = 300;
 28 |   boolean ranOut = false; //true if after 500 moves the clone hasnt died, gotten trapped or eaten the food, so its probably looping
 29 | 
 30 | 
 31 |   int growCount = 0;
 32 | 
 33 | 
 34 | 
 35 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 36 |   //constructor
 37 |   SuperSnakeClone(SuperSnake original, NeuralNet chosenBrain) {
 38 |     //copy the position, tailPositions, length, brain, time to live and food from the original
 39 | 
 40 |     pos = new PVector(original.pos.x, original.pos.y);
 41 |     tailPositions = (ArrayList)original.tailPositions.clone();
 42 |     len = original.len;
 43 |     food = original.food.clone();
 44 |     brain = chosenBrain.clone();
 45 |     leftToLive = original.leftToLive;
 46 |     growCount = original.growCount;
 47 |   }
 48 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 49 |   
 50 |   //runs the clone until it dies, finds the food is trapped or takes over 500 moves to do any of these things
 51 |   void runClone() {
 52 |     for (int i = 0; i< 500; i++) {
 53 |       //update clone
 54 |       look();
 55 |       setVelocity();
 56 |       move();
 57 |       if (!alive || foodFound || trapped) {//if anything interesting happened then stop the clone        
 58 |         return;
 59 |       }
 60 | 
 61 |     }
 62 |     ranOut = true; // the snake is probably in a loop
 63 |   }
 64 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 65 | 
 66 |   //from an output array returns an int indicating the direction the snake should go
 67 |   int getDirection(float[] netOutputs) {
 68 |     float max = 0;
 69 |     int maxIndex = 0;
 70 | 
 71 |     for (int i = 0; i < netOutputs.length; i++) {
 72 |       if (max < netOutputs[i]) {
 73 |         max = netOutputs[i];
 74 |         maxIndex = i;
 75 |       }
 76 |     }
 77 |     return maxIndex;
 78 |   }
 79 | 
 80 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 81 |   //set the velocity from the output of the neural network
 82 |   void setVelocity() {
 83 |     //get the output of the neural network
 84 |     int direction = getDirection(brain.output(vision));
 85 | 
 86 |     //get the maximum position in the output array and use this as the decision on which direction to go
 87 | 
 88 |     //set the velocity based on this decision
 89 |     switch(direction) {
 90 |     case 0:
 91 |       vel = new PVector(-10, 0);
 92 |       break;
 93 |     case 1:
 94 |       vel = new PVector(0, -10);
 95 |       break;
 96 |     case 2:
 97 |       vel = new PVector(10, 0);
 98 |       break;
 99 |     case 3:
100 |       vel = new PVector(0, 10);
101 |       break;
102 |     }
103 |   }
104 | 
105 | 
106 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
107 |   //move the snake in direction of the vel PVector
108 |   void move() {
109 | 
110 |     //increment moveCount
111 |     moveCount+=1;
112 |     //move through time
113 |     leftToLive -=1;
114 | 
115 |     //if time left to live is up then kill the snake
116 |     if (leftToLive < 0) {
117 |       alive = false;
118 |       return;
119 |     }
120 | 
121 |     //if the snake hit itself or the edge then kill it
122 |     if (gonnaDie(pos.x + vel.x, pos.y + vel.y)) {
123 |       alive= false;
124 |       return;
125 |     }
126 | 
127 |     //if the snake is trapped then set it as trapped and end the clone
128 |     if (isTrapped()) {
129 |       trapped = true;
130 |       return;
131 |     }
132 | 
133 |     //if the snake is on  the same position as the food then set it as found food and end the clone
134 |     //Note the snake cannot be trapped and find food so no need to test it
135 |     if (pos.x + vel.x == food.pos.x && pos.y + vel.y == food.pos.y) {
136 |       foodFound = true;
137 |       return;
138 |     }
139 | 
140 | 
141 |     //not growing then move all the tail positions to follow the head
142 |     //nice
143 |     if (growCount > 0) {
144 |       growCount --;
145 |       grow();
146 |     } else {
147 |       for (int i = 0; i< tailPositions.size() -1; i++) {
148 |         temp = new PVector(tailPositions.get(i+1).x, tailPositions.get(i+1).y);
149 |         tailPositions.set(i, temp);
150 |       }
151 | 
152 |       if (len>1) {
153 |         temp = new PVector(pos.x, pos.y);
154 |         tailPositions.set(len-2, temp);
155 |       }
156 |     }
157 |     //actually move the snakes head
158 |     pos.add(vel);
159 | 
160 |     //if the clone can see the food and hasnt already seen the food (we want the shortest point to seeing the food) then set the number of moves it took to see it
161 |     if (!seenFood && seeFood()) {
162 |       seenFood = true;
163 |       foodSeenAtCount = moveCount;
164 |     }
165 |   }
166 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
167 |   //grows the snake by 1 square
168 |   void grow() {
169 |     //add the head to the tail list this simulates the snake growing as the head is the only thing which moves
170 |     temp = new PVector(pos.x, pos.y);
171 |     tailPositions.add(temp);
172 |     len +=1;
173 |   }
174 | 
175 | 
176 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
177 |   //is the food within sight (only 4 directions) cannot see through tail
178 |   boolean seeFood() {
179 |     //look in 4 directions for the food
180 |     PVector left = new PVector(pos.x-10, pos.y);
181 |     PVector right = new PVector(pos.x+10, pos.y);
182 |     PVector up = new PVector(pos.x, pos.y-10);
183 |     PVector down = new PVector(pos.x, pos.y+10);
184 | 
185 | 
186 |     //look left until found the wall the snakes body or the food
187 |     //while the left vector is not on the tail or out 
188 |     while (!gonnaDie(left.x, left.y)) {
189 |       //if the left vector is on the food then the snake can see the food and thus return true
190 |       if (left.x == food.pos.x && left.y == food.pos.y) {
191 |         return true;
192 |       }
193 |       //look further left
194 |       left.x-=10;
195 |     }
196 |     //look right for food
197 |     while (!gonnaDie(right.x, right.y)) {
198 |       if (right.x == food.pos.x && right.y == food.pos.y) {
199 |         return true;
200 |       }
201 |       right.x+=10;
202 |     }
203 | 
204 |     //look up for food
205 |     while (!gonnaDie(up.x, up.y)) {
206 |       if (up.x == food.pos.x && up.y == food.pos.y) {
207 |         return true;
208 |       }
209 |       up.y -=10;
210 |     }
211 |     //look down for food
212 |     while (!gonnaDie(down.x, down.y)) {
213 |       if (down.x == food.pos.x && down.y == food.pos.y) {
214 |         return true;
215 |       }
216 |       down.y+=10;
217 |     }
218 | 
219 |     //if not seen in any of the 4 directions then return false
220 |     return false;
221 |   }
222 | 
223 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
224 |   //returns true if the snake is going to hit itself or a wall
225 |   boolean gonnaDie(float x, float y) {
226 |     //check if hit wall
227 |     if (x < 400 || y < 0 || x >= 800 || y >= 400) {
228 |       return true;
229 |     }
230 | 
231 |     //check if hit tail
232 |     return isOnTail(x, y);
233 |   }
234 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------    
235 |   //returns true if the coordinates is on the snakes tail
236 |   boolean isOnTail(float x, float y) {
237 |     for (int i = 0; i < tailPositions.size(); i++) {
238 |       if (x == tailPositions.get(i).x &&  y == tailPositions.get(i).y) {
239 |         return true;
240 |       }
241 |     }
242 | 
243 |     return false;
244 |   }
245 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
246 |   //this function return whether or not the snake is trapped, trapped meaning that the snake is trapped within its own tail
247 |   boolean isTrapped() {
248 |     //stores all the points within the tails 'trap' 
249 |     blanks = new ArrayList<PVector>();
250 |     countNextTo(pos.x, pos.y);//call recursive function to add all the blanks which are reachable from the head of the snake
251 |     
252 |     //if the amount of spaces is less than half the remaining positions(1600 - tailPositions.size()) or less than 300 whichever is less
253 |     //then it considered as trapped so return true 
254 |     //otherwise return false
255 |     return (blanks.size() <= min((1600 - tailPositions.size())/2, 300));
256 |   }
257 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
258 |   
259 |   //adds all the blanks which are reachable from the head of the snake to the blanks ArrayList 
260 |   //see isTrapped function above for more info
261 |   //recursively  calls itself to find all blanks within the snakes tail
262 |   void countNextTo(float x, float y) {
263 |     //no need to add more positions to blank if already considered not trapped
264 |     if (blanks.size() <= min((1600 - tailPositions.size())/2, 300)) {
265 |       temp = new PVector(x+10, y);//the position to check if its blank
266 |       
267 |       //if not out or on the tail then add it to the blank ArrayList and then look for other blanks around that position by calling this function again 
268 |       if (!gonnaDie(temp.x, temp.y) && !blanks.contains(temp)) {
269 |         blanks.add(temp);
270 |         countNextTo(temp.x, temp.y);
271 |       }
272 |       //look to the left
273 |       temp = new PVector(x-10, y);
274 |       if (!gonnaDie(temp.x, temp.y) && !blanks.contains(temp)) {
275 |         blanks.add(temp);
276 |         countNextTo(temp.x, temp.y);
277 |       }
278 |       //look down
279 |       temp = new PVector(x, y+10);
280 |       if (!gonnaDie(temp.x, temp.y) && !blanks.contains(temp)) {
281 |         blanks.add(temp);
282 |         countNextTo(temp.x, temp.y);
283 |       }
284 |       //look up
285 |       temp = new PVector(x, y-10);
286 |       if (!gonnaDie(temp.x, temp.y) && !blanks.contains(temp)) {
287 |         blanks.add(temp);
288 |         countNextTo(temp.x, temp.y);
289 |       }
290 |     }
291 |   }
292 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
293 | 
294 |   //looks in 8 directions to find food,walls and its tail
295 |   void look() {
296 |     vision = new float[24];
297 |     //look left
298 |     float[] tempValues = lookInDirection(new PVector(-10, 0));
299 |     vision[0] = tempValues[0];
300 |     vision[1] = tempValues[1];
301 |     vision[2] = tempValues[2];
302 |     //look left/up  
303 |     tempValues = lookInDirection(new PVector(-10, -10));
304 |     vision[3] = tempValues[0];
305 |     vision[4] = tempValues[1];
306 |     vision[5] = tempValues[2];
307 |     //look up
308 |     tempValues = lookInDirection(new PVector(0, -10));
309 |     vision[6] = tempValues[0];
310 |     vision[7] = tempValues[1];
311 |     vision[8] = tempValues[2];
312 |     //look up/right
313 |     tempValues = lookInDirection(new PVector(10, -10));
314 |     vision[9] = tempValues[0];
315 |     vision[10] = tempValues[1];
316 |     vision[11] = tempValues[2];
317 |     //look right
318 |     tempValues = lookInDirection(new PVector(10, 0));
319 |     vision[12] = tempValues[0];
320 |     vision[13] = tempValues[1];
321 |     vision[14] = tempValues[2];
322 |     //look right/down
323 |     tempValues = lookInDirection(new PVector(10, 10));
324 |     vision[15] = tempValues[0];
325 |     vision[16] = tempValues[1];
326 |     vision[17] = tempValues[2];
327 |     //look down
328 |     tempValues = lookInDirection(new PVector(0, 10));
329 |     vision[18] = tempValues[0];
330 |     vision[19] = tempValues[1];
331 |     vision[20] = tempValues[2];
332 |     //look down/left
333 |     tempValues = lookInDirection(new PVector(-10, 10));
334 |     vision[21] = tempValues[0];
335 |     vision[22] = tempValues[1];
336 |     vision[23] = tempValues[2];
337 |   }
338 | 
339 | 
340 |   float[] lookInDirection(PVector direction) {
341 |     //set up a temp array to hold the values that are going to be passed to the main vision array
342 |     float[] visionInDirection = new float[3];
343 | 
344 |     PVector position = new PVector(pos.x, pos.y);//the position where we are currently looking for food or tail or wall
345 |     boolean foodIsFound = false;//true if the food has been located in the direction looked
346 |     boolean tailIsFound = false;//true if the tail has been located in the direction looked 
347 |     float distance = 0;
348 |     //move once in the desired direction before starting 
349 |     position.add(direction);
350 |     distance +=1;
351 | 
352 |     //look in the direction until you reach a wall
353 |     while (!(position.x < 400 || position.y < 0 || position.x >= 800 || position.y >= 400)) {
354 | 
355 |       //check for food at the position
356 |       if (!foodIsFound && position.x == food.pos.x && position.y == food.pos.y) {
357 |         visionInDirection[0] = 1;
358 |         foodIsFound = true; // dont check if food is already found
359 |       }
360 | 
361 |       //check for tail at the position
362 |       if (!tailIsFound && isOnTail(position.x, position.y)) {
363 |         visionInDirection[1] = 1/distance;
364 |         tailIsFound = true; // dont check if tail is already found
365 |       }
366 | 
367 |       //look further in the direction
368 |       position.add(direction);
369 |       distance +=1;
370 |     }
371 | 
372 |     //set the distance to the wall
373 |     visionInDirection[2] = 1/distance;
374 | 
375 |     return visionInDirection;
376 |   }
377 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/World.pde:
--------------------------------------------------------------------------------
  1 | class World {
  2 |   int gen = 0;//the current generation the world is up to
  3 | 
  4 |   //all the populations/species in the world 
  5 |   Population[] species;
  6 | 
  7 |   NeuralNet[] topBrains;//array containing the brains of the snakes of legend
  8 |   SuperSnake fusedSnake;//the superFusion snake
  9 |   //Snake worldBestSnake; //the best snake out of all the populations
 10 |   int worldBestScore = 0;// the best score of the best snake out of all the populations, like a world record
 11 | 
 12 |   Snake[] SnakesOfLegend; // the snakes which are loaded from file and are the best ever
 13 |   Snake legend; // a temp position to store one of these legends
 14 |   int legendNo; // the position the currently tested legend has in the snakes of legend array
 15 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 16 |   //constructor
 17 |   World(int speciesNo, int popSize) {
 18 | 
 19 |     //initiate species
 20 |     species = new Population[speciesNo];
 21 |     for (int i = 0; i< speciesNo; i++) {
 22 |       species[i] = new Population(popSize);
 23 |     }
 24 | 
 25 |     //initiates snakes of legends
 26 |     SnakesOfLegend = new Snake[5];
 27 |     for (int i = 0; i<SnakesOfLegend.length; i++) {
 28 |       SnakesOfLegend[i] = new Snake();
 29 |     }
 30 | 
 31 |     //initiate topbrains
 32 |     topBrains = new NeuralNet[SnakesOfLegend.length];
 33 |   }
 34 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 35 |   //updates all the species in the world
 36 |   void updateAlive() {
 37 |     for (int i = 0; i< species.length; i++) {
 38 |       species[i].updateAlive();
 39 |     }
 40 |   }
 41 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 42 |   //runs the genetic algorithm on all the species
 43 |   void geneticAlgorithm() {
 44 |     for (int i = 0; i< species.length; i++) {
 45 |       species[i].calcFitness();
 46 |       species[i].naturalSelection();
 47 |       //species[i].mutate();
 48 |     }
 49 |     gen+=1;
 50 |     setTopScore();
 51 |     //if any of the top snakes from the species is better than the any of the saved snakes then save them
 52 |     for (int i = 0; i< species.length; i++) {
 53 |       saveTopSnake(i);
 54 |     }
 55 |   }
 56 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 57 |   //load the snakes of legend from file
 58 |   void loadBestSnakes() {
 59 |     for (int i = 0; i< 5; i++) {
 60 |       SnakesOfLegend[i] = SnakesOfLegend[i].loadSnake(i);
 61 |       
 62 |     }
 63 |   }
 64 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 65 |   //creates the super snake from all the snakes of legend
 66 |   void snakeFusion() {
 67 |     loadBestSnakes();
 68 | 
 69 |     //populates the topBrians array with the brains of the best snakes
 70 |     for (int i = 0; i< SnakesOfLegend.length; i++) {
 71 |       topBrains[i] = SnakesOfLegend[i].brain.clone();
 72 |     }
 73 | 
 74 |     fusedSnake = new SuperSnake(topBrains);
 75 |   }
 76 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 77 |   //update the state of the supersnake
 78 |   void updateSuperSnake() {
 79 | 
 80 |     fusedSnake.look();
 81 |     fusedSnake.setVelocity(); 
 82 |     fusedSnake.move();
 83 |     fusedSnake.show();
 84 |     saveFrame("output/superSnake/frame_#######.png");
 85 |   }  
 86 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 87 |   //update the legend snake test
 88 |   void updateLegend() {
 89 | 
 90 |     legend.look();
 91 |     legend.setVelocity();
 92 |     legend.move();
 93 |     legend.show();
 94 | 
 95 |   }
 96 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 97 |   //test if all the snakes from all the species are dead
 98 |   boolean done() {
 99 |     for (int i = 0; i< species.length; i++) {
100 |       if (!species[i].done()) {
101 |         return false;
102 |       }
103 |     }
104 |     return true;
105 |   }
106 | 
107 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
108 |   //set the top score from the global best scores of each species
109 |   void setTopScore() {
110 |     long max = 0;
111 |     int maxIndex = 0;
112 |     for (int i = 0; i< species.length; i++) {
113 |       if (species[i].globalBestFitness > max ) {
114 |         max = species[i].globalBestFitness;
115 |         maxIndex = i;
116 |       }
117 |     }
118 | 
119 |     worldBestScore = species[maxIndex].globalBest;
120 |   }
121 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
122 | 
123 |   //saves the top snake of the parameter no. species if it has a better score than any of the legends
124 |   void saveTopSnake(int speciesNo) {
125 | 
126 |     //load the data about which legend spaces have already been assigned a snake 
127 |     Table t = loadTable("data/snakesStored.csv");
128 |     int snakeNo = -1;
129 |     TableRow tr = t.getRow(0);
130 |     for (int i = 0; i< t.getColumnCount(); i++) {
131 |       if (tr.getInt(i) == 0) {
132 |         snakeNo = i;
133 |         break;
134 |       }
135 |     }
136 |     //if there are any free spaces store the top snake of this species
137 |     if (snakeNo!= -1) {
138 |       species[speciesNo].globalBestSnake.clone().saveSnake(snakeNo, species[speciesNo].globalBest, species[speciesNo].populationID);
139 |       tr=t.getRow(0);
140 |       tr.setInt(snakeNo, 1);
141 |       saveTable(t, "data/snakesStored.csv");
142 |     } else {
143 |       //if snake positions are full
144 |       //check for snakes from this population to stop snakes from the same generation populating the entire legend list
145 |       Table t1;
146 |       TableRow tr1;
147 |       for (int i = 0; i< t.getColumnCount(); i++) {
148 |         t1 = loadTable("data/SnakeStats" + i+ ".csv", "header");
149 |         tr1 = t1.getRow(0);
150 |         if (tr1.getInt(1) == species[speciesNo].populationID) {
151 |           if (species[speciesNo].globalBest > tr1.getInt(0)) { //if the currently loaded snake is from this population and worse than the best snake
152 |             species[speciesNo].globalBestSnake.clone().saveSnake(i, species[speciesNo].globalBest, species[speciesNo].populationID);//save the snake
153 |           }
154 |           return;//exit the function
155 |         }
156 |       }
157 | 
158 |       //if no snakes from this species are stored then overload the legend with the lowest score if its lower than the score of the top snake of this species
159 | 
160 |       int min = species[speciesNo].globalBest;
161 |       int minIndex = -1;
162 | 
163 |       for (int i = 0; i< t.getColumnCount(); i++) {
164 |         t1 = loadTable("data/SnakeStats" + i+ ".csv", "header");
165 |         tr1 = t1.getRow(0);
166 |         if (tr1.getInt(0) < min) {
167 |           min = tr1.getInt(0);
168 |           minIndex = i;//
169 |         }
170 |       }
171 | 
172 |       //if the snake to be saved isnt better than any of them dont save it
173 |       if (minIndex!= -1) {
174 |         species[speciesNo].globalBestSnake.clone().saveSnake(minIndex, species[speciesNo].globalBest, species[speciesNo].populationID);//save snake
175 |       }
176 |     }
177 |   }
178 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
179 |   //get a legend ready for testing
180 |   void playLegend(int snakeNo) {
181 |     loadBestSnakes();
182 |     legend = SnakesOfLegend[snakeNo].clone();
183 |     legendNo = snakeNo;
184 |     legend.test = true;
185 |   }
186 | 
187 | //---------------------------------------------------------------------------------------------------------------------------------------------------------  
188 | 
189 |   //for training the legends to reach higher levels of awesome
190 |   World( int popSize, Snake[] legendsArray) {
191 | 
192 |     //initiate species
193 |     species = new Population[legendsArray.length];
194 | 
195 |     //set each population to be a mutated version of the legend in the array
196 |     for (int i = 0; i< legendsArray.length; i++) {
197 |       species[i] = new Population(popSize, legendsArray[i]);
198 |     }
199 | 
200 |     //set the population ID's for each population to stop overwriting the snakes data
201 |     Table t ;
202 |     for (int i = 0; i< legendsArray.length; i++) {
203 |       t = loadTable("data/SnakeStats" + i+ ".csv", "header");
204 |       TableRow tr = t.getRow(0);
205 |       species[i].populationID = tr.getInt(1);
206 |     }
207 |   }
208 |   
209 | }


--------------------------------------------------------------------------------
/SmartSnakesCombine/data/snakesStored.csv:
--------------------------------------------------------------------------------
1 | 0,0,0,0,0
2 | 


--------------------------------------------------------------------------------