├── README.md
└── TemplateNeat
    ├── Genome.pde
    ├── Node.pde
    ├── Player.pde
    ├── Population.pde
    ├── Species.pde
    ├── TemplateNeat.pde
    ├── connectionGene.pde
    └── connectionHistory.pde


/README.md:
--------------------------------------------------------------------------------
 1 | # NEAT_Template
 2 | This is mainly for me, but if anyone wishes to use it then go ahead.
 3 | 
 4 | This is an empty template which you can add to any game that you make for processing. 
 5 | this will neat it 
 6 | to see how i use it check out some of my projects
 7 | 
 8 | 
 9 | bye
10 | 


--------------------------------------------------------------------------------
/TemplateNeat/Genome.pde:
--------------------------------------------------------------------------------
  1 | class Genome {
  2 |   ArrayList<connectionGene> genes = new  ArrayList<connectionGene>();//a list of connections between nodes which represent the NN
  3 |   ArrayList<Node> nodes = new ArrayList<Node>();//list of nodes
  4 |   int inputs;
  5 |   int outputs;
  6 |   int layers =2;
  7 |   int nextNode = 0;
  8 |   int biasNode;
  9 | 
 10 |   ArrayList<Node> network = new ArrayList<Node>();//a list of the nodes in the order that they need to be considered in the NN
 11 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 12 |   Genome(int in, int out) {
 13 |     //set input number and output number
 14 |     inputs = in;
 15 |     outputs = out;
 16 | 
 17 |     //create input nodes
 18 |     for (int i = 0; i<inputs; i++) {
 19 |       nodes.add(new Node(i));
 20 |       nextNode ++;
 21 |       nodes.get(i).layer =0;
 22 |     }
 23 | 
 24 |     //create output nodes
 25 |     for (int i = 0; i < outputs; i++) {
 26 |       nodes.add(new Node(i+inputs));
 27 |       nodes.get(i+inputs).layer = 1;
 28 |       nextNode++;
 29 |     }
 30 | 
 31 |     nodes.add(new Node(nextNode));//bias node
 32 |     biasNode = nextNode; 
 33 |     nextNode++;
 34 |     nodes.get(biasNode).layer = 0;
 35 |   }
 36 | 
 37 | 
 38 | 
 39 |   //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 40 |   //returns the node with a matching number
 41 |   //sometimes the nodes will not be in order
 42 |   Node getNode(int nodeNumber) {
 43 |     for (int i = 0; i < nodes.size(); i++) {
 44 |       if (nodes.get(i).number == nodeNumber) {
 45 |         return nodes.get(i);
 46 |       }
 47 |     }
 48 |     return null;
 49 |   }
 50 | 
 51 | 
 52 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 53 |   //adds the conenctions going out of a node to that node so that it can acess the next node during feeding forward
 54 |   void connectNodes() {
 55 | 
 56 |     for (int i = 0; i< nodes.size(); i++) {//clear the connections
 57 |       nodes.get(i).outputConnections.clear();
 58 |     }
 59 | 
 60 |     for (int i = 0; i < genes.size(); i++) {//for each connectionGene 
 61 |       genes.get(i).fromNode.outputConnections.add(genes.get(i));//add it to node
 62 |     }
 63 |   }
 64 | 
 65 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 66 |   //feeding in input values into the NN and returning output array
 67 |   float[] feedForward(float[] inputValues) {
 68 |     //set the outputs of the input nodes
 69 |     for (int i =0; i < inputs; i++) {
 70 |       nodes.get(i).outputValue = inputValues[i];
 71 |     }
 72 |     nodes.get(biasNode).outputValue = 1;//output of bias is 1
 73 | 
 74 |     for (int i = 0; i< network.size(); i++) {//for each node in the network engage it(see node class for what this does)
 75 |       network.get(i).engage();
 76 |     }
 77 | 
 78 |     //the outputs are nodes[inputs] to nodes [inputs+outputs-1]
 79 |     float[] outs = new float[outputs];
 80 |     for (int i = 0; i < outputs; i++) {
 81 |       outs[i] = nodes.get(inputs + i).outputValue;
 82 |     }
 83 | 
 84 |     for (int i = 0; i < nodes.size(); i++) {//reset all the nodes for the next feed forward
 85 |       nodes.get(i).inputSum = 0;
 86 |     }
 87 | 
 88 |     return outs;
 89 |   }
 90 | 
 91 |   //----------------------------------------------------------------------------------------------------------------------------------------
 92 |   //sets up the NN as a list of nodes in order to be engaged 
 93 | 
 94 |   void generateNetwork() {
 95 |     connectNodes();
 96 |     network = new ArrayList<Node>();
 97 |     //for each layer add the node in that layer, since layers cannot connect to themselves there is no need to order the nodes within a layer
 98 | 
 99 |     for (int l = 0; l< layers; l++) {//for each layer
100 |       for (int i = 0; i< nodes.size(); i++) {//for each node
101 |         if (nodes.get(i).layer == l) {//if that node is in that layer
102 |           network.add(nodes.get(i));
103 |         }
104 |       }
105 |     }
106 |   }
107 |   //-----------------------------------------------------------------------------------------------------------------------------------------
108 |   //mutate the NN by adding a new node
109 |   //it does this by picking a random connection and disabling it then 2 new connections are added 
110 |   //1 between the input node of the disabled connection and the new node
111 |   //and the other between the new node and the output of the disabled connection
112 |   void addNode(ArrayList<connectionHistory> innovationHistory) {
113 |     //pick a random connection to create a node between
114 |     if (genes.size() ==0) {
115 |       addConnection(innovationHistory); 
116 |       return;
117 |     }
118 |     int randomConnection = floor(random(genes.size()));
119 | 
120 |     while (genes.get(randomConnection).fromNode == nodes.get(biasNode) && genes.size() !=1 ) {//dont disconnect bias
121 |       randomConnection = floor(random(genes.size()));
122 |     }
123 | 
124 |     genes.get(randomConnection).enabled = false;//disable it
125 | 
126 |     int newNodeNo = nextNode;
127 |     nodes.add(new Node(newNodeNo));
128 |     nextNode ++;
129 |     //add a new connection to the new node with a weight of 1
130 |     int connectionInnovationNumber = getInnovationNumber(innovationHistory, genes.get(randomConnection).fromNode, getNode(newNodeNo));
131 |     genes.add(new connectionGene(genes.get(randomConnection).fromNode, getNode(newNodeNo), 1, connectionInnovationNumber));
132 | 
133 | 
134 |     connectionInnovationNumber = getInnovationNumber(innovationHistory, getNode(newNodeNo), genes.get(randomConnection).toNode);
135 |     //add a new connection from the new node with a weight the same as the disabled connection
136 |     genes.add(new connectionGene(getNode(newNodeNo), genes.get(randomConnection).toNode, genes.get(randomConnection).weight, connectionInnovationNumber));
137 |     getNode(newNodeNo).layer = genes.get(randomConnection).fromNode.layer +1;
138 | 
139 | 
140 |     connectionInnovationNumber = getInnovationNumber(innovationHistory, nodes.get(biasNode), getNode(newNodeNo));
141 |     //connect the bias to the new node with a weight of 0 
142 |     genes.add(new connectionGene(nodes.get(biasNode), getNode(newNodeNo), 0, connectionInnovationNumber));
143 | 
144 |     //if the layer of the new node is equal to the layer of the output node of the old connection then a new layer needs to be created
145 |     //more accurately the layer numbers of all layers equal to or greater than this new node need to be incrimented
146 |     if (getNode(newNodeNo).layer == genes.get(randomConnection).toNode.layer) {
147 |       for (int i = 0; i< nodes.size() -1; i++) {//dont include this newest node
148 |         if (nodes.get(i).layer >= getNode(newNodeNo).layer) {
149 |           nodes.get(i).layer ++;
150 |         }
151 |       }
152 |       layers ++;
153 |     }
154 |     connectNodes();
155 |   }
156 | 
157 |   //------------------------------------------------------------------------------------------------------------------
158 |   //adds a connection between 2 nodes which aren't currently connected
159 |   void addConnection(ArrayList<connectionHistory> innovationHistory) {
160 |     //cannot add a connection to a fully connected network
161 |     if (fullyConnected()) {
162 |       println("connection failed");
163 |       return;
164 |     }
165 | 
166 | 
167 |     //get random nodes
168 |     int randomNode1 = floor(random(nodes.size())); 
169 |     int randomNode2 = floor(random(nodes.size()));
170 |     while (randomConnectionNodesAreShit(randomNode1, randomNode2)) {//while the random nodes are no good
171 |       //get new ones
172 |       randomNode1 = floor(random(nodes.size())); 
173 |       randomNode2 = floor(random(nodes.size()));
174 |     }
175 |     int temp;
176 |     if (nodes.get(randomNode1).layer > nodes.get(randomNode2).layer) {//if the first random node is after the second then switch
177 |       temp =randomNode2  ;
178 |       randomNode2 = randomNode1;
179 |       randomNode1 = temp;
180 |     }    
181 | 
182 |     //get the innovation number of the connection
183 |     //this will be a new number if no identical genome has mutated in the same way 
184 |     int connectionInnovationNumber = getInnovationNumber(innovationHistory, nodes.get(randomNode1), nodes.get(randomNode2));
185 |     //add the connection with a random array
186 | 
187 |     genes.add(new connectionGene(nodes.get(randomNode1), nodes.get(randomNode2), random(-1, 1), connectionInnovationNumber));//changed this so if error here
188 |     connectNodes();
189 |   }
190 |   //-------------------------------------------------------------------------------------------------------------------------------------------
191 |   boolean randomConnectionNodesAreShit(int r1, int r2) {
192 |     if (nodes.get(r1).layer == nodes.get(r2).layer) return true; // if the nodes are in the same layer 
193 |     if (nodes.get(r1).isConnectedTo(nodes.get(r2))) return true; //if the nodes are already connected
194 | 
195 | 
196 | 
197 |     return false;
198 |   }
199 | 
200 |   //-------------------------------------------------------------------------------------------------------------------------------------------
201 |   //returns the innovation number for the new mutation
202 |   //if this mutation has never been seen before then it will be given a new unique innovation number
203 |   //if this mutation matches a previous mutation then it will be given the same innovation number as the previous one
204 |   int getInnovationNumber(ArrayList<connectionHistory> innovationHistory, Node from, Node to) {
205 |     boolean isNew = true;
206 |     int connectionInnovationNumber = nextConnectionNo;
207 |     for (int i = 0; i < innovationHistory.size(); i++) {//for each previous mutation
208 |       if (innovationHistory.get(i).matches(this, from, to)) {//if match found
209 |         isNew = false;//its not a new mutation
210 |         connectionInnovationNumber = innovationHistory.get(i).innovationNumber; //set the innovation number as the innovation number of the match
211 |         break;
212 |       }
213 |     }
214 | 
215 |     if (isNew) {//if the mutation is new then create an arrayList of integers representing the current state of the genome
216 |       ArrayList<Integer> innoNumbers = new ArrayList<Integer>();
217 |       for (int i = 0; i< genes.size(); i++) {//set the innovation numbers
218 |         innoNumbers.add(genes.get(i).innovationNo);
219 |       }
220 | 
221 |       //then add this mutation to the innovationHistory 
222 |       innovationHistory.add(new connectionHistory(from.number, to.number, connectionInnovationNumber, innoNumbers));
223 |       nextConnectionNo++;
224 |     }
225 |     return connectionInnovationNumber;
226 |   }
227 |   //----------------------------------------------------------------------------------------------------------------------------------------
228 | 
229 |   //returns whether the network is fully connected or not
230 |   boolean fullyConnected() {
231 |     int maxConnections = 0;
232 |     int[] nodesInLayers = new int[layers];//array which stored the amount of nodes in each layer
233 | 
234 |     //populate array
235 |     for (int i =0; i< nodes.size(); i++) {
236 |       nodesInLayers[nodes.get(i).layer] +=1;
237 |     }
238 | 
239 |     //for each layer the maximum amount of connections is the number in this layer * the number of nodes infront of it
240 |     //so lets add the max for each layer together and then we will get the maximum amount of connections in the network
241 |     for (int i = 0; i < layers-1; i++) {
242 |       int nodesInFront = 0;
243 |       for (int j = i+1; j < layers; j++) {//for each layer infront of this layer
244 |         nodesInFront += nodesInLayers[j];//add up nodes
245 |       }
246 | 
247 |       maxConnections += nodesInLayers[i] * nodesInFront;
248 |     }
249 | 
250 |     if (maxConnections == genes.size()) {//if the number of connections is equal to the max number of connections possible then it is full
251 |       return true;
252 |     }
253 |     return false;
254 |   }
255 | 
256 | 
257 |   //-------------------------------------------------------------------------------------------------------------------------------
258 |   //mutates the genome
259 |   void mutate(ArrayList<connectionHistory> innovationHistory) {
260 |     if (genes.size() ==0) {
261 |       addConnection(innovationHistory);
262 |     }
263 | 
264 |     float rand1 = random(1);
265 |     if (rand1<0.8) { // 80% of the time mutate weights
266 |       for (int i = 0; i< genes.size(); i++) {
267 |         genes.get(i).mutateWeight();
268 |       }
269 |     }
270 |     //5% of the time add a new connection
271 |     float rand2 = random(1);
272 |     if (rand2<0.08) {
273 |       addConnection(innovationHistory);
274 |     }
275 | 
276 | 
277 |     //1% of the time add a node
278 |     float rand3 = random(1);
279 |     if (rand3<0.02) {
280 |       addNode(innovationHistory);
281 |     }
282 |   }
283 | 
284 |   //---------------------------------------------------------------------------------------------------------------------------------
285 |   //called when this Genome is better that the other parent
286 |   Genome crossover(Genome parent2) {
287 |     Genome child = new Genome(inputs, outputs, true);
288 |     child.genes.clear();
289 |     child.nodes.clear();
290 |     child.layers = layers;
291 |     child.nextNode = nextNode;
292 |     child.biasNode = biasNode;
293 |     ArrayList<connectionGene> childGenes = new ArrayList<connectionGene>();//list of genes to be inherrited form the parents
294 |     ArrayList<Boolean> isEnabled = new ArrayList<Boolean>(); 
295 |     //all inherrited genes
296 |     for (int i = 0; i< genes.size(); i++) {
297 |       boolean setEnabled = true;//is this node in the chlid going to be enabled
298 | 
299 |       int parent2gene = matchingGene(parent2, genes.get(i).innovationNo);
300 |       if (parent2gene != -1) {//if the genes match
301 |         if (!genes.get(i).enabled || !parent2.genes.get(parent2gene).enabled) {//if either of the matching genes are disabled
302 | 
303 |           if (random(1) < 0.75) {//75% of the time disabel the childs gene
304 |             setEnabled = false;
305 |           }
306 |         }
307 |         float rand = random(1);
308 |         if (rand<0.5) {
309 |           childGenes.add(genes.get(i));
310 | 
311 |           //get gene from this fucker
312 |         } else {
313 |           //get gene from parent2
314 |           childGenes.add(parent2.genes.get(parent2gene));
315 |         }
316 |       } else {//disjoint or excess gene
317 |         childGenes.add(genes.get(i));
318 |         setEnabled = genes.get(i).enabled;
319 |       }
320 |       isEnabled.add(setEnabled);
321 |     }
322 | 
323 | 
324 |     //since all excess and disjoint genes are inherrited from the more fit parent (this Genome) the childs structure is no different from this parent | with exception of dormant connections being enabled but this wont effect nodes
325 |     //so all the nodes can be inherrited from this parent
326 |     for (int i = 0; i < nodes.size(); i++) {
327 |       child.nodes.add(nodes.get(i).clone());
328 |     }
329 | 
330 |     //clone all the connections so that they connect the childs new nodes
331 | 
332 |     for ( int i =0; i<childGenes.size(); i++) {
333 |       child.genes.add(childGenes.get(i).clone(child.getNode(childGenes.get(i).fromNode.number), child.getNode(childGenes.get(i).toNode.number)));
334 |       child.genes.get(i).enabled = isEnabled.get(i);
335 |     }
336 | 
337 |     child.connectNodes();
338 |     return child;
339 |   }
340 | 
341 |   //----------------------------------------------------------------------------------------------------------------------------------------
342 |   //create an empty genome
343 |   Genome(int in, int out, boolean crossover) {
344 |     //set input number and output number
345 |     inputs = in; 
346 |     outputs = out;
347 |   }
348 |   //----------------------------------------------------------------------------------------------------------------------------------------
349 |   //returns whether or not there is a gene matching the input innovation number  in the input genome
350 |   int matchingGene(Genome parent2, int innovationNumber) {
351 |     for (int i =0; i < parent2.genes.size(); i++) {
352 |       if (parent2.genes.get(i).innovationNo == innovationNumber) {
353 |         return i;
354 |       }
355 |     }
356 |     return -1; //no matching gene found
357 |   }
358 |   //----------------------------------------------------------------------------------------------------------------------------------------
359 |   //prints out info about the genome to the console 
360 |   void printGenome() {
361 |     println("Print genome  layers:", layers);  
362 |     println("bias node: "  + biasNode);
363 |     println("nodes");
364 |     for (int i = 0; i < nodes.size(); i++) {
365 |       print(nodes.get(i).number + ",");
366 |     }
367 |     println("Genes");
368 |     for (int i = 0; i < genes.size(); i++) {//for each connectionGene 
369 |       println("gene " + genes.get(i).innovationNo, "From node " + genes.get(i).fromNode.number, "To node " + genes.get(i).toNode.number, 
370 |         "is enabled " +genes.get(i).enabled, "from layer " + genes.get(i).fromNode.layer, "to layer " + genes.get(i).toNode.layer, "weight: " + genes.get(i).weight);
371 |     }
372 | 
373 |     println();
374 |   }
375 | 
376 |   //----------------------------------------------------------------------------------------------------------------------------------------
377 |   //returns a copy of this genome
378 |   Genome clone() {
379 | 
380 |     Genome clone = new Genome(inputs, outputs, true);
381 | 
382 |     for (int i = 0; i < nodes.size(); i++) {//copy nodes
383 |       clone.nodes.add(nodes.get(i).clone());
384 |     }
385 | 
386 |     //copy all the connections so that they connect the clone new nodes
387 | 
388 |     for ( int i =0; i<genes.size(); i++) {//copy genes
389 |       clone.genes.add(genes.get(i).clone(clone.getNode(genes.get(i).fromNode.number), clone.getNode(genes.get(i).toNode.number)));
390 |     }
391 | 
392 |     clone.layers = layers;
393 |     clone.nextNode = nextNode;
394 |     clone.biasNode = biasNode;
395 |     clone.connectNodes();
396 | 
397 |     return clone;
398 |   }
399 |   //----------------------------------------------------------------------------------------------------------------------------------------
400 |   //draw the genome on the screen
401 |   void drawGenome(int startX, int startY, int w, int h) {
402 |     //i know its ugly but it works (and is not that important) so I'm not going to mess with it
403 |     ArrayList<ArrayList<Node>> allNodes = new ArrayList<ArrayList<Node>>();
404 |     ArrayList<PVector> nodePoses = new ArrayList<PVector>();
405 |     ArrayList<Integer> nodeNumbers= new ArrayList<Integer>();
406 | 
407 |     //get the positions on the screen that each node is supposed to be in
408 | 
409 | 
410 |     //split the nodes into layers
411 |     for (int i = 0; i< layers; i++) {
412 |       ArrayList<Node> temp = new ArrayList<Node>();
413 |       for (int j = 0; j< nodes.size(); j++) {//for each node 
414 |         if (nodes.get(j).layer == i ) {//check if it is in this layer
415 |           temp.add(nodes.get(j)); //add it to this layer
416 |         }
417 |       }
418 |       allNodes.add(temp);//add this layer to all nodes
419 |     }
420 | 
421 |     //for each layer add the position of the node on the screen to the node posses arraylist
422 |     for (int i = 0; i < layers; i++) {
423 |       fill(255, 0, 0);
424 |       float x = startX + (float)((i+1)*w)/(float)(layers+1.0);
425 |       for (int j = 0; j< allNodes.get(i).size(); j++) {//for the position in the layer
426 |         float y = startY + ((float)(j + 1.0) * h)/(float)(allNodes.get(i).size() + 1.0);
427 |         nodePoses.add(new PVector(x, y));
428 |         nodeNumbers.add(allNodes.get(i).get(j).number);
429 |       }
430 |     }
431 | 
432 |     //draw connections 
433 |     stroke(0);
434 |     strokeWeight(2);
435 |     for (int i = 0; i< genes.size(); i++) {
436 |       if (genes.get(i).enabled) {
437 |         stroke(0);
438 |       } else {
439 |         stroke(100);
440 |       }
441 |       PVector from;
442 |       PVector to;
443 |       from = nodePoses.get(nodeNumbers.indexOf(genes.get(i).fromNode.number));
444 |       to = nodePoses.get(nodeNumbers.indexOf(genes.get(i).toNode.number));
445 |       if (genes.get(i).weight > 0) {
446 |         stroke(255, 0, 0);
447 |       } else {
448 |         stroke(0, 0, 255);
449 |       }
450 |       strokeWeight(map(abs(genes.get(i).weight), 0, 1, 0, 5));
451 |       line(from.x, from.y, to.x, to.y);
452 |     }
453 | 
454 |     //draw nodes last so they appear ontop of the connection lines
455 |     for (int i = 0; i < nodePoses.size(); i++) {
456 |       fill(255);
457 |       stroke(0);
458 |       strokeWeight(1);
459 |       ellipse(nodePoses.get(i).x, nodePoses.get(i).y, 20, 20);
460 |       textSize(10);
461 |       fill(0);
462 |       textAlign(CENTER, CENTER);
463 | 
464 | 
465 |       text(nodeNumbers.get(i), nodePoses.get(i).x, nodePoses.get(i).y);
466 |     }
467 |   }
468 | }


--------------------------------------------------------------------------------
/TemplateNeat/Node.pde:
--------------------------------------------------------------------------------
 1 | class Node {
 2 |   int number;
 3 |   float inputSum = 0;//current sum i.e. before activation
 4 |   float outputValue = 0; //after activation function is applied
 5 |   ArrayList<connectionGene> outputConnections = new ArrayList<connectionGene>();
 6 |   int layer = 0;
 7 |   PVector drawPos = new PVector();
 8 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 9 |   //constructor
10 |   Node(int no) {
11 |     number = no;
12 |   }
13 | 
14 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
15 |   //the node sends its output to the inputs of the nodes its connected to
16 |   void engage() {
17 |     if (layer!=0) {//no sigmoid for the inputs and bias
18 |       outputValue = sigmoid(inputSum);
19 |     }
20 | 
21 |     for (int i = 0; i< outputConnections.size(); i++) {//for each connection
22 |       if (outputConnections.get(i).enabled) {//dont do shit if not enabled
23 |         outputConnections.get(i).toNode.inputSum += outputConnections.get(i).weight * outputValue;//add the weighted output to the sum of the inputs of whatever node this node is connected to
24 |       }
25 |     }
26 |  }
27 | //----------------------------------------------------------------------------------------------------------------------------------------
28 | //not used
29 |   float stepFunction(float x) {
30 |     if (x < 0) {
31 |       return 0;
32 |     } else {
33 |       return 1;
34 |     }
35 |   }
36 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
37 | //sigmoid activation function
38 |   float sigmoid(float x) {
39 |     float y = 1 / (1 + pow((float)Math.E, -4.9*x));
40 |     return y;
41 |   }
42 |   //----------------------------------------------------------------------------------------------------------------------------------------------------------
43 |   //returns whether this node connected to the parameter node
44 |   //used when adding a new connection 
45 |   boolean isConnectedTo(Node node) {
46 |     if (node.layer == layer) {//nodes in the same layer cannot be connected
47 |       return false;
48 |     }
49 | 
50 |     //you get it
51 |     if (node.layer < layer) {
52 |       for (int i = 0; i < node.outputConnections.size(); i++) {
53 |         if (node.outputConnections.get(i).toNode == this) {
54 |           return true;
55 |         }
56 |       }
57 |     } else {
58 |       for (int i = 0; i < outputConnections.size(); i++) {
59 |         if (outputConnections.get(i).toNode == node) {
60 |           return true;
61 |         }
62 |       }
63 |     }
64 | 
65 |     return false;
66 |   }
67 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
68 |   //returns a copy of this node
69 |   Node clone() {
70 |     Node clone = new Node(number);
71 |     clone.layer = layer;
72 |     return clone;
73 |   }
74 | }


--------------------------------------------------------------------------------
/TemplateNeat/Player.pde:
--------------------------------------------------------------------------------
  1 | class Player {
  2 |   float fitness;
  3 |   Genome brain;
  4 |   float[] vision = new float[8];//the input array fed into the neuralNet 
  5 |   float[] decision = new float[4]; //the out put of the NN 
  6 |   float unadjustedFitness;
  7 |   int lifespan = 0;//how long the player lived for fitness
  8 |   int bestScore =0;//stores the score achieved used for replay
  9 |   boolean dead;
 10 |   int score;
 11 |   int gen = 0;
 12 |   
 13 |   int genomeInputs = 13;
 14 |   int genomeOutputs = 4;
 15 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 16 |   //constructor
 17 | 
 18 |   Player() {
 19 |     brain = new Genome(genomeInputs,genomeOutputs);
 20 |   }
 21 | 
 22 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 23 |   void show() {
 24 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 25 |   }
 26 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 27 |   void move() {
 28 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 29 |   }
 30 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 31 |   void update() {
 32 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 33 |   }
 34 |   //----------------------------------------------------------------------------------------------------------------------------------------------------------
 35 | 
 36 |   void look() {
 37 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 38 |    
 39 |   }
 40 | 
 41 | 
 42 | 
 43 | 
 44 |  
 45 | 
 46 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 47 |   //gets the output of the brain then converts them to actions
 48 |   void think() {
 49 | 
 50 |     float max = 0;
 51 |     int maxIndex = 0;
 52 |     //get the output of the neural network
 53 |     decision = brain.feedForward(vision);
 54 | 
 55 |     for (int i = 0; i < decision.length; i++) {
 56 |       if (decision[i] > max) {
 57 |         max = decision[i];
 58 |         maxIndex = i;
 59 |       }
 60 |     }
 61 |     
 62 |     //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 63 | 
 64 | 
 65 |   }
 66 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------  
 67 |   //returns a clone of this player with the same brian
 68 |   Player clone() {
 69 |     Player clone = new Player();
 70 |     clone.brain = brain.clone();
 71 |     clone.fitness = fitness;
 72 |     clone.brain.generateNetwork(); 
 73 |     clone.gen = gen;
 74 |     clone.bestScore = score;
 75 |     return clone;
 76 |   }
 77 | 
 78 | //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 79 | //since there is some randomness in games sometimes when we want to replay the game we need to remove that randomness
 80 | //this fuction does that
 81 | 
 82 |   Player cloneForReplay() {
 83 |     Player clone = new Player();
 84 |     clone.brain = brain.clone();
 85 |     clone.fitness = fitness;
 86 |     clone.brain.generateNetwork();
 87 |     clone.gen = gen;
 88 |     clone.bestScore = score;
 89 |     //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 90 |     return clone;
 91 |   }
 92 | 
 93 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
 94 |   //fot Genetic algorithm
 95 |   void calculateFitness() {
 96 |     //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 97 | 
 98 |   }
 99 | 
100 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
101 |   Player crossover(Player parent2) {
102 |     Player child = new Player();
103 |     child.brain = brain.crossover(parent2.brain);
104 |     child.brain.generateNetwork();
105 |     return child;
106 |   }
107 | }


--------------------------------------------------------------------------------
/TemplateNeat/Population.pde:
--------------------------------------------------------------------------------
  1 | class Population {
  2 |   ArrayList<Player> pop = new ArrayList<Player>();
  3 |   Player bestPlayer;//the best ever player 
  4 |   int bestScore =0;//the score of the best ever player
  5 |   //int species = 0;
  6 |   int gen;
  7 |   //int nextConnectionNumber;
  8 |   ArrayList<connectionHistory> innovationHistory = new ArrayList<connectionHistory>();
  9 |   ArrayList<Player> genPlayers = new ArrayList<Player>();
 10 |   ArrayList<Species> species = new ArrayList<Species>();
 11 | 
 12 |   boolean massExtinctionEvent = false;
 13 |   boolean newStage = false;
 14 | 
 15 |   //------------------------------------------------------------------------------------------------------------------------------------------
 16 |   //constructor
 17 |   Population(int size) {
 18 | 
 19 |     for (int i =0; i<size; i++) {
 20 |       pop.add(new Player());
 21 |       pop.get(i).brain.generateNetwork();
 22 |       pop.get(i).brain.mutate(innovationHistory);
 23 |     }
 24 |   }
 25 |   //------------------------------------------------------------------------------------------------------------------------------------------
 26 |   //update all the players which are alive
 27 |   void updateAlive() {
 28 | 
 29 |     for (int i = 0; i< pop.size(); i++) {
 30 |       if (!pop.get(i).dead) {
 31 |         pop.get(i).look();//get inputs for brain 
 32 |         pop.get(i).think();//use outputs from neural network
 33 |         pop.get(i).update();//move the player according to the outputs from the neural network
 34 |         if (!showNothing && (!showBest || i ==0)) {
 35 |           pop.get(i).show();
 36 |         }
 37 |       }
 38 |     }
 39 |   }
 40 | 
 41 |   //------------------------------------------------------------------------------------------------------------------------------------------
 42 |   //returns true if all the players are dead      sad
 43 |   boolean done() {
 44 |     for (int i = 0; i< pop.size(); i++) {
 45 |       if (!pop.get(i).dead) {
 46 |         return false;
 47 |       }
 48 |     }
 49 |     return true;
 50 |   }
 51 |   //------------------------------------------------------------------------------------------------------------------------------------------
 52 |   //sets the best player globally and for this gen
 53 |   void setBestPlayer() {
 54 |     Player tempBest =  species.get(0).players.get(0);
 55 |     tempBest.gen = gen;
 56 | 
 57 | 
 58 |     //if best this gen is better than the global best score then set the global best as the best this gen
 59 | 
 60 |     if (tempBest.score > bestScore) {
 61 |       genPlayers.add(tempBest.cloneForReplay());
 62 |       println("old best:", bestScore);
 63 |       println("new best:", tempBest.score);
 64 |       bestScore = tempBest.score;
 65 |       bestPlayer = tempBest.cloneForReplay();
 66 |     }
 67 |   }
 68 | 
 69 |   //------------------------------------------------------------------------------------------------------------------------------------------------
 70 |   //this function is called when all the players in the population are dead and a new generation needs to be made
 71 |   void naturalSelection() {
 72 |     speciate();//seperate the population into species 
 73 |     calculateFitness();//calculate the fitness of each player
 74 |     sortSpecies();//sort the species to be ranked in fitness order, best first
 75 |     if (massExtinctionEvent) { 
 76 |       massExtinction();
 77 |       massExtinctionEvent = false;
 78 |     }
 79 |     cullSpecies();//kill off the bottom half of each species
 80 |     setBestPlayer();//save the best player of this gen
 81 |     killStaleSpecies();//remove species which haven't improved in the last 15(ish) generations
 82 |     killBadSpecies();//kill species which are so bad that they cant reproduce
 83 | 
 84 | 
 85 |     println("generation", gen, "Number of mutations", innovationHistory.size(), "species: " + species.size(), "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
 86 | 
 87 | 
 88 |     float averageSum = getAvgFitnessSum();
 89 |     ArrayList<Player> children = new ArrayList<Player>();//the next generation
 90 |     println("Species:");               
 91 |     for (int j = 0; j < species.size(); j++) {//for each species
 92 | 
 93 |       println("best unadjusted fitness:", species.get(j).bestFitness);
 94 |       for (int i = 0; i < species.get(j).players.size(); i++) {
 95 |         print("player " + i, "fitness: " +  species.get(j).players.get(i).fitness, "score " + species.get(j).players.get(i).score, ' ');
 96 |       }
 97 |       println();
 98 |       children.add(species.get(j).champ.cloneForReplay());//add champion without any mutation
 99 | 
100 |       int NoOfChildren = floor(species.get(j).averageFitness/averageSum * pop.size()) -1;//the number of children this species is allowed, note -1 is because the champ is already added
101 |       for (int i = 0; i< NoOfChildren; i++) {//get the calculated amount of children from this species
102 |         children.add(species.get(j).giveMeBaby(innovationHistory));
103 |       }
104 |     }
105 | 
106 |     while (children.size() < pop.size()) {//if not enough babies (due to flooring the number of children to get a whole int) 
107 |       children.add(species.get(0).giveMeBaby(innovationHistory));//get babies from the best species
108 |     }
109 |     pop.clear();
110 |     pop = (ArrayList)children.clone(); //set the children as the current population
111 |     gen+=1;
112 |     for (int i = 0; i< pop.size(); i++) {//generate networks for each of the children
113 |       pop.get(i).brain.generateNetwork();
114 |     }
115 | 
116 |   }
117 | 
118 |   //------------------------------------------------------------------------------------------------------------------------------------------
119 |   //seperate population into species based on how similar they are to the leaders of each species in the previous gen
120 |   void speciate() {
121 |     for (Species s : species) {//empty species
122 |       s.players.clear();
123 |     }
124 |     for (int i = 0; i< pop.size(); i++) {//for each player
125 |       boolean speciesFound = false;
126 |       for (Species s : species) {//for each species
127 |         if (s.sameSpecies(pop.get(i).brain)) {//if the player is similar enough to be considered in the same species
128 |           s.addToSpecies(pop.get(i));//add it to the species
129 |           speciesFound = true;
130 |           break;
131 |         }
132 |       }
133 |       if (!speciesFound) {//if no species was similar enough then add a new species with this as its champion
134 |         species.add(new Species(pop.get(i)));
135 |       }
136 |     }
137 |   }
138 |   //------------------------------------------------------------------------------------------------------------------------------------------
139 |   //calculates the fitness of all of the players 
140 |   void calculateFitness() {
141 |     for (int i =1; i<pop.size(); i++) {
142 |       pop.get(i).calculateFitness();
143 |     }
144 |   }
145 |   //------------------------------------------------------------------------------------------------------------------------------------------
146 |   //sorts the players within a species and the species by their fitnesses
147 |   void sortSpecies() {
148 |     //sort the players within a species
149 |     for (Species s : species) {
150 |       s.sortSpecies();
151 |     }
152 | 
153 |     //sort the species by the fitness of its best player
154 |     //using selection sort like a loser
155 |     ArrayList<Species> temp = new ArrayList<Species>();
156 |     for (int i = 0; i < species.size(); i ++) {
157 |       float max = 0;
158 |       int maxIndex = 0;
159 |       for (int j = 0; j< species.size(); j++) {
160 |         if (species.get(j).bestFitness > max) {
161 |           max = species.get(j).bestFitness;
162 |           maxIndex = j;
163 |         }
164 |       }
165 |       temp.add(species.get(maxIndex));
166 |       species.remove(maxIndex);
167 |       i--;
168 |     }
169 |     species = (ArrayList)temp.clone();
170 |   }
171 |   //------------------------------------------------------------------------------------------------------------------------------------------
172 |   //kills all species which haven't improved in 15 generations
173 |   void killStaleSpecies() {
174 |     for (int i = 2; i< species.size(); i++) {
175 |       if (species.get(i).staleness >= 15) {
176 |         species.remove(i);
177 |         i--;
178 |       }
179 |     }
180 |   }
181 |   //------------------------------------------------------------------------------------------------------------------------------------------
182 |   //if a species sucks so much that it wont even be allocated 1 child for the next generation then kill it now
183 |   void killBadSpecies() {
184 |     float averageSum = getAvgFitnessSum();
185 | 
186 |     for (int i = 1; i< species.size(); i++) {
187 |       if (species.get(i).averageFitness/averageSum * pop.size() < 1) {//if wont be given a single child 
188 |         species.remove(i);//sad
189 |         i--;
190 |       }
191 |     }
192 |   }
193 |   //------------------------------------------------------------------------------------------------------------------------------------------
194 |   //returns the sum of each species average fitness
195 |   float getAvgFitnessSum() {
196 |     float averageSum = 0;
197 |     for (Species s : species) {
198 |       averageSum += s.averageFitness;
199 |     }
200 |     return averageSum;
201 |   }
202 | 
203 |   //------------------------------------------------------------------------------------------------------------------------------------------
204 |   //kill the bottom half of each species
205 |   void cullSpecies() {
206 |     for (Species s : species) {
207 |       s.cull(); //kill bottom half
208 |       s.fitnessSharing();//also while we're at it lets do fitness sharing
209 |       s.setAverage();//reset averages because they will have changed
210 |     }
211 |   }
212 | 
213 | 
214 |   void massExtinction() {
215 |     for (int i =5; i< species.size(); i++) {
216 |       species.remove(i);//sad
217 |       i--;
218 |     }
219 |   }
220 | }


--------------------------------------------------------------------------------
/TemplateNeat/Species.pde:
--------------------------------------------------------------------------------
  1 | class Species {
  2 |   ArrayList<Player> players = new ArrayList<Player>();
  3 |   float bestFitness = 0;
  4 |   Player champ;
  5 |   float averageFitness = 0;
  6 |   int staleness = 0;//how many generations the species has gone without an improvement
  7 |   Genome rep;
  8 | 
  9 |   //--------------------------------------------
 10 |   //coefficients for testing compatibility 
 11 |   float excessCoeff = 1;
 12 |   float weightDiffCoeff = 0.5;
 13 |   float compatibilityThreshold = 3;
 14 |   //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 15 |   //empty constructor
 16 | 
 17 |   Species() {
 18 |   }
 19 | 
 20 | 
 21 |   //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 
 22 |   //constructor which takes in the player which belongs to the species
 23 |   Species(Player p) {
 24 |     players.add(p); 
 25 |     //since it is the only one in the species it is by default the best
 26 |     bestFitness = p.fitness; 
 27 |     rep = p.brain.clone();
 28 |     champ = p.cloneForReplay();
 29 |   }
 30 | 
 31 |   //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 
 32 |   //returns whether the parameter genome is in this species
 33 |   boolean sameSpecies(Genome g) {
 34 |     float compatibility;
 35 |     float excessAndDisjoint = getExcessDisjoint(g, rep);//get the number of excess and disjoint genes between this player and the current species rep
 36 |     float averageWeightDiff = averageWeightDiff(g, rep);//get the average weight difference between matching genes
 37 | 
 38 | 
 39 |     float largeGenomeNormaliser = g.genes.size() - 20;
 40 |     if (largeGenomeNormaliser<1) {
 41 |       largeGenomeNormaliser =1;
 42 |     }
 43 | 
 44 |     compatibility =  (excessCoeff* excessAndDisjoint/largeGenomeNormaliser) + (weightDiffCoeff* averageWeightDiff);//compatablilty formula
 45 |     return (compatibilityThreshold > compatibility);
 46 |   }
 47 | 
 48 |   //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 
 49 |   //add a player to the species
 50 |   void addToSpecies(Player p) {
 51 |     players.add(p);
 52 |   }
 53 | 
 54 |   //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 
 55 |   //returns the number of excess and disjoint genes between the 2 input genomes
 56 |   //i.e. returns the number of genes which dont match
 57 |   float getExcessDisjoint(Genome brain1, Genome brain2) {
 58 |     float matching = 0.0;
 59 |     for (int i =0; i <brain1.genes.size(); i++) {
 60 |       for (int j = 0; j < brain2.genes.size(); j++) {
 61 |         if (brain1.genes.get(i).innovationNo == brain2.genes.get(j).innovationNo) {
 62 |           matching ++;
 63 |           break;
 64 |         }
 65 |       }
 66 |     }
 67 |     return (brain1.genes.size() + brain2.genes.size() - 2*(matching));//return no of excess and disjoint genes
 68 |   }
 69 |   //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 70 |   //returns the avereage weight difference between matching genes in the input genomes
 71 |   float averageWeightDiff(Genome brain1, Genome brain2) {
 72 |     if (brain1.genes.size() == 0 || brain2.genes.size() ==0) {
 73 |       return 0;
 74 |     }
 75 | 
 76 | 
 77 |     float matching = 0;
 78 |     float totalDiff= 0;
 79 |     for (int i =0; i <brain1.genes.size(); i++) {
 80 |       for (int j = 0; j < brain2.genes.size(); j++) {
 81 |         if (brain1.genes.get(i).innovationNo == brain2.genes.get(j).innovationNo) {
 82 |           matching ++;
 83 |           totalDiff += abs(brain1.genes.get(i).weight - brain2.genes.get(j).weight);
 84 |           break;
 85 |         }
 86 |       }
 87 |     }
 88 |     if (matching ==0) {//divide by 0 error
 89 |       return 100;
 90 |     }
 91 |     return totalDiff/matching;
 92 |   }
 93 |   //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 94 |   //sorts the species by fitness 
 95 |   void sortSpecies() {
 96 | 
 97 |     ArrayList<Player> temp = new ArrayList<Player>();
 98 | 
 99 |     //selection short 
100 |     for (int i = 0; i < players.size(); i ++) {
101 |       float max = 0;
102 |       int maxIndex = 0;
103 |       for (int j = 0; j< players.size(); j++) {
104 |         if (players.get(j).fitness > max) {
105 |           max = players.get(j).fitness;
106 |           maxIndex = j;
107 |         }
108 |       }
109 |       temp.add(players.get(maxIndex));
110 |       players.remove(maxIndex);
111 |       i--;
112 |     }
113 | 
114 |     players = (ArrayList)temp.clone();
115 |     if (players.size() == 0) {
116 |       print("fucking"); 
117 |       staleness = 200;
118 |       return;
119 |     }
120 |     //if new best player
121 |     if (players.get(0).fitness > bestFitness) {
122 |       staleness = 0;
123 |       bestFitness = players.get(0).fitness;
124 |       rep = players.get(0).brain.clone();
125 |       champ = players.get(0).cloneForReplay();
126 |     } else {//if no new best player
127 |       staleness ++;
128 |     }
129 |   }
130 | 
131 |   //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
132 |   //simple stuff
133 |   void setAverage() {
134 | 
135 |     float sum = 0;
136 |     for (int i = 0; i < players.size(); i ++) {
137 |       sum += players.get(i).fitness;
138 |     }
139 |     averageFitness = sum/players.size();
140 |   }
141 |   //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
142 | 
143 |   //gets baby from the players in this species
144 |   Player giveMeBaby(ArrayList<connectionHistory> innovationHistory) {
145 |     Player baby;
146 |     if (random(1) < 0.25) {//25% of the time there is no crossover and the child is simply a clone of a random(ish) player
147 |       baby =  selectPlayer().clone();
148 |     } else {//75% of the time do crossover 
149 | 
150 |       //get 2 random(ish) parents 
151 |       Player parent1 = selectPlayer();
152 |       Player parent2 = selectPlayer();
153 | 
154 |       //the crossover function expects the highest fitness parent to be the object and the lowest as the argument
155 |       if (parent1.fitness < parent2.fitness) {
156 |         baby =  parent2.crossover(parent1);
157 |       } else {
158 |         baby =  parent1.crossover(parent2);
159 |       }
160 |     }
161 |     baby.brain.mutate(innovationHistory);//mutate that baby brain
162 |     return baby;
163 |   }
164 | 
165 |   //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
166 |   //selects a player based on it fitness
167 |   Player selectPlayer() {
168 |     float fitnessSum = 0;
169 |     for (int i =0; i<players.size(); i++) {
170 |       fitnessSum += players.get(i).fitness;
171 |     }
172 | 
173 |     float rand = random(fitnessSum);
174 |     float runningSum = 0;
175 | 
176 |     for (int i = 0; i<players.size(); i++) {
177 |       runningSum += players.get(i).fitness; 
178 |       if (runningSum > rand) {
179 |         return players.get(i);
180 |       }
181 |     }
182 |     //unreachable code to make the parser happy
183 |     return players.get(0);
184 |   }
185 |   //------------------------------------------------------------------------------------------------------------------------------------------
186 |   //kills off bottom half of the species
187 |   void cull() {
188 |     if (players.size() > 2) {
189 |       for (int i = players.size()/2; i<players.size(); i++) {
190 |         players.remove(i); 
191 |         i--;
192 |       }
193 |     }
194 |   }
195 |   //------------------------------------------------------------------------------------------------------------------------------------------
196 |   //in order to protect unique players, the fitnesses of each player is divided by the number of players in the species that that player belongs to 
197 |   void fitnessSharing() {
198 |     for (int i = 0; i< players.size(); i++) {
199 |       players.get(i).fitness/=players.size();
200 |     }
201 |   }
202 | }


--------------------------------------------------------------------------------
/TemplateNeat/TemplateNeat.pde:
--------------------------------------------------------------------------------
  1 | //this is a template to add a NEAT ai to any game
  2 | //note //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace 
  3 | //this means that there is some information specific to the game to input here
  4 | 
  5 | 
  6 | int nextConnectionNo = 1000;
  7 | Population pop;
  8 | int speed = 60;
  9 | 
 10 | 
 11 | boolean showBest = true;//true if only show the best of the previous generation
 12 | boolean runBest = false; //true if replaying the best ever game
 13 | boolean humanPlaying = false; //true if the user is playing
 14 | 
 15 | Player humanPlayer;
 16 | 
 17 | boolean runThroughSpecies = false;
 18 | int upToSpecies = 0;
 19 | Player speciesChamp;
 20 | 
 21 | boolean showBrain = false;
 22 | 
 23 | boolean showBestEachGen = false;
 24 | int upToGen = 0;
 25 | Player genPlayerTemp;
 26 | 
 27 | boolean showNothing = false;
 28 | 
 29 | 
 30 | //--------------------------------------------------------------------------------------------------------------------------------------------------
 31 | 
 32 | void setup() {
 33 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
 34 |   pop = new Population(500);
 35 |   humanPlayer = new Player();
 36 | }
 37 | //--------------------------------------------------------------------------------------------------------------------------------------------------------
 38 | void draw() {
 39 |   drawToScreen();
 40 |   if (showBestEachGen) {//show the best of each gen
 41 |     if (!genPlayerTemp.dead) {//if current gen player is not dead then update it
 42 | 
 43 |       genPlayerTemp.look();
 44 |       genPlayerTemp.think();
 45 |       genPlayerTemp.update();
 46 |       genPlayerTemp.show();
 47 |     } else {//if dead move on to the next generation
 48 |       upToGen ++;
 49 |       if (upToGen >= pop.genPlayers.size()) {//if at the end then return to the start and stop doing it
 50 |         upToGen= 0;
 51 |         showBestEachGen = false;
 52 |       } else {//if not at the end then get the next generation
 53 |         genPlayerTemp = pop.genPlayers.get(upToGen).cloneForReplay();
 54 |       }
 55 |     }
 56 |   } else
 57 |     if (runThroughSpecies ) {//show all the species 
 58 |       if (!speciesChamp.dead) {//if best player is not dead
 59 |         speciesChamp.look();
 60 |         speciesChamp.think();
 61 |         speciesChamp.update();
 62 |         speciesChamp.show();
 63 |       } else {//once dead
 64 |         upToSpecies++;
 65 |         if (upToSpecies >= pop.species.size()) { 
 66 |           runThroughSpecies = false;
 67 |         } else {
 68 |           speciesChamp = pop.species.get(upToSpecies).champ.cloneForReplay();
 69 |         }
 70 |       }
 71 |     } else {
 72 |       if (humanPlaying) {//if the user is controling the ship[
 73 |         if (!humanPlayer.dead) {//if the player isnt dead then move and show the player based on input
 74 |           humanPlayer.look();
 75 |           humanPlayer.update();
 76 |           humanPlayer.show();
 77 |         } else {//once done return to ai
 78 |           humanPlaying = false;
 79 |         }
 80 |       } else 
 81 |       if (runBest) {// if replaying the best ever game
 82 |         if (!pop.bestPlayer.dead) {//if best player is not dead
 83 |           pop.bestPlayer.look();
 84 |           pop.bestPlayer.think();
 85 |           pop.bestPlayer.update();
 86 |           pop.bestPlayer.show();
 87 |         } else {//once dead
 88 |           runBest = false;//stop replaying it
 89 |           pop.bestPlayer = pop.bestPlayer.cloneForReplay();//reset the best player so it can play again
 90 |         }
 91 |       } else {//if just evolving normally
 92 |         if (!pop.done()) {//if any players are alive then update them
 93 |           pop.updateAlive();
 94 |         } else {//all dead
 95 |           //genetic algorithm 
 96 |           pop.naturalSelection();
 97 |         }
 98 |       }
 99 |     }
100 | }
101 | 
102 | 
103 | //---------------------------------------------------------------------------------------------------------------------------------------------------------
104 | //draws the display screen
105 | void drawToScreen() {
106 |   if (!showNothing) {
107 |    //pretty stuff
108 |     //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
109 |     
110 |     drawBrain();
111 |     writeInfo();
112 |   }
113 | }
114 | //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
115 | void drawBrain() {  //show the brain of whatever genome is currently showing
116 |   int startX = 0;//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
117 |   int startY = 0;
118 |   int w = 0;
119 |   int h = 0;
120 |   if (runThroughSpecies) {
121 |     speciesChamp.brain.drawGenome(startX,startY,w,h);
122 |   } else
123 |     if (runBest) {
124 |       pop.bestPlayer.brain.drawGenome(startX,startY,w,h);
125 |     } else
126 |       if (humanPlaying) {
127 |         showBrain = false;
128 |       } else if (showBestEachGen) {
129 |         genPlayerTemp.brain.drawGenome(startX,startY,w,h);
130 |       } else {
131 |         pop.pop.get(0).brain.drawGenome(startX,startY,w,h);
132 |       }
133 | }
134 | //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
135 | //writes info about the current player
136 | void writeInfo() {
137 |   fill(200);
138 |   textAlign(LEFT);
139 |   textSize(30);
140 |   if (showBestEachGen) {
141 |     text("Score: " + genPlayerTemp.score, 650, 50);//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
142 |     text("Gen: " + (genPlayerTemp.gen +1), 1150, 50);
143 |   } else
144 |     if (runThroughSpecies) {
145 |       text("Score: " + speciesChamp.score, 650, 50);//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
146 |       text("Species: " + (upToSpecies +1), 1150, 50);
147 |       text("Players in this Species: " + pop.species.get(upToSpecies).players.size(), 50, height/2 + 200);
148 |     } else
149 |       if (humanPlaying) {
150 |         text("Score: " + humanPlayer.score, 650, 50);//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
151 |       } else
152 |         if (runBest) {
153 |           text("Score: " + pop.bestPlayer.score, 650, 50);//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
154 |           text("Gen: " + pop.gen, 1150, 50);
155 |         } else {
156 |           if (showBest) {          
157 |             text("Score: " + pop.pop.get(0).score, 650, 50);//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
158 |             text("Gen: " + pop.gen, 1150, 50);
159 |             text("Species: " + pop.species.size(), 50, height/2 + 300);
160 |             text("Global Best Score: " + pop.bestScore, 50, height/2 + 200);
161 |           }
162 |         }
163 | }
164 | 
165 | //--------------------------------------------------------------------------------------------------------------------------------------------------
166 | 
167 | void keyPressed() {
168 |   switch(key) {
169 |   case ' ':
170 |     //toggle showBest
171 |     showBest = !showBest;
172 |     break;
173 |   case '+'://speed up frame rate
174 |     speed += 10;
175 |     frameRate(speed);
176 |     println(speed);
177 |     break;
178 |   case '-'://slow down frame rate
179 |     if (speed > 10) {
180 |       speed -= 10;
181 |       frameRate(speed);
182 |       println(speed);
183 |     }
184 |     break;
185 |   case 'b'://run the best
186 |     runBest = !runBest;
187 |     break;
188 |   case 's'://show species
189 |     runThroughSpecies = !runThroughSpecies;
190 |     upToSpecies = 0;
191 |     speciesChamp = pop.species.get(upToSpecies).champ.cloneForReplay();
192 |     break;
193 |   case 'g'://show generations
194 |     showBestEachGen = !showBestEachGen;
195 |     upToGen = 0;
196 |     genPlayerTemp = pop.genPlayers.get(upToGen).clone();
197 |     break;
198 |   case 'n'://show absolutely nothing in order to speed up computation
199 |     showNothing = !showNothing;
200 |     break;
201 |   case 'p'://play
202 |     humanPlaying = !humanPlaying;
203 |     humanPlayer = new Player();
204 |     break; 
205 |   case CODED://any of the arrow keys
206 |     switch(keyCode) {
207 |     case UP://the only time up/ down / left is used is to control the player
208 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
209 |       break;
210 |     case DOWN:
211 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
212 |       break;
213 |     case LEFT:
214 | //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
215 |       break;
216 |     case RIGHT://right is used to move through the generations
217 |       if (runThroughSpecies) {//if showing the species in the current generation then move on to the next species
218 |         upToSpecies++;
219 |         if (upToSpecies >= pop.species.size()) {
220 |           runThroughSpecies = false;
221 |         } else {
222 |           speciesChamp = pop.species.get(upToSpecies).champ.cloneForReplay();
223 |         }
224 |       } else 
225 |       if (showBestEachGen) {//if showing the best player each generation then move on to the next generation
226 |         upToGen++;
227 |         if (upToGen >= pop.genPlayers.size()) {//if reached the current generation then exit out of the showing generations mode
228 |           showBestEachGen = false;
229 |         } else {
230 |           genPlayerTemp = pop.genPlayers.get(upToGen).cloneForReplay();
231 |         }
232 |       } else if (humanPlaying) {//if the user is playing then move player right
233 | 
234 |         //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<replace
235 |       }
236 |       break;
237 |     }
238 |     break;
239 |   }
240 | }


--------------------------------------------------------------------------------
/TemplateNeat/connectionGene.pde:
--------------------------------------------------------------------------------
 1 | //a connection between 2 nodes
 2 | class connectionGene {
 3 |   Node fromNode;
 4 |   Node toNode;
 5 |   float weight;
 6 |   boolean enabled = true;
 7 |   int innovationNo;//each connection is given a innovation number to compare genomes
 8 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 9 |   //constructor
10 |   connectionGene(Node from, Node to, float w, int inno) {
11 |     fromNode = from;
12 |     toNode = to;
13 |     weight = w;
14 |     innovationNo = inno;
15 |   }
16 | 
17 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
18 |    //changes the weight
19 |   void mutateWeight() {
20 |     float rand2 = random(1);
21 |     if (rand2 < 0.1) {//10% of the time completely change the weight
22 |       weight = random(-1, 1);
23 |     } else {//otherwise slightly change it
24 |       weight += randomGaussian()/50;
25 |       //keep weight between bounds
26 |       if(weight > 1){
27 |         weight = 1;
28 |       }
29 |       if(weight < -1){
30 |         weight = -1;        
31 |         
32 |       }
33 |     }
34 |   }
35 | 
36 |   //----------------------------------------------------------------------------------------------------------
37 |   //returns a copy of this connectionGene
38 |   connectionGene clone(Node from, Node  to) {
39 |     connectionGene clone = new connectionGene(from, to, weight, innovationNo);
40 |     clone.enabled = enabled;
41 | 
42 |     return clone;
43 |   }
44 | }


--------------------------------------------------------------------------------
/TemplateNeat/connectionHistory.pde:
--------------------------------------------------------------------------------
 1 | class connectionHistory {
 2 |   int fromNode;
 3 |   int toNode;
 4 |   int innovationNumber;
 5 | 
 6 |   ArrayList<Integer> innovationNumbers = new ArrayList<Integer>();//the innovation Numbers from the connections of the genome which first had this mutation 
 7 |   //this represents the genome and allows us to test if another genoeme is the same
 8 |   //this is before this connection was added
 9 | 
10 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
11 |   //constructor
12 |   connectionHistory(int from, int to, int inno, ArrayList<Integer> innovationNos) {
13 |     fromNode = from;
14 |     toNode = to;
15 |     innovationNumber = inno;
16 |     innovationNumbers = (ArrayList)innovationNos.clone();
17 |   }
18 |   //---------------------------------------------------------------------------------------------------------------------------------------------------------
19 |   //returns whether the genome matches the original genome and the connection is between the same nodes
20 |   boolean matches(Genome genome, Node from, Node to) {
21 |     if (genome.genes.size() == innovationNumbers.size()) { //if the number of connections are different then the genoemes aren't the same
22 |       if (from.number == fromNode && to.number == toNode) {
23 |         //next check if all the innovation numbers match from the genome
24 |         for (int i = 0; i< genome.genes.size(); i++) {
25 |           if (!innovationNumbers.contains(genome.genes.get(i).innovationNo)) {
26 |             return false;
27 |           }
28 |         }
29 | 
30 |         //if reached this far then the innovationNumbers match the genes innovation numbers and the connection is between the same nodes
31 |         //so it does match
32 |         return true;
33 |       }
34 |     }
35 |     return false;
36 |   }
37 | }


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