/* Creature - Contains the workings for the Creature class */////////////////////////////////////////////////////////#include <Base/Base.h>#include <ode/ode.h>#include "Creature.h"#include "Genome.h"#include "Gene.h"#include "Neuron.h"// Member Functions////////////////////////////////////////////////////////createRepresentation - Transforms the herited genome data into a real, usable// representation of the creaturevoid Creature::createRepresentation(){ // Sort out the genome ////////////////////////////////////////////////// //Clear the existing information m_genomeRep.clearGenes(); //Recurse through our existing genome walkGenome(0, -1, 0, 0); // Fix up the neural connections ////////////////////////////////////////////////// //Walk through our new representation genome for (u32 i=0; i < m_genomeRep.size(); ++i) { //Walk through the neuron list Gene &rep = m_genomeRep.at(i); for (u32 j=0; j < rep.m_neurons.size(); ++j) { //Examine the connections Neuron &neur = rep.m_neurons.at(j); for (u32 k=0; k < neur.m_conns.size(); ++k) { //Examine the connections Neuron::Connection &con = neur.m_conns.at(k); //If the connection comes from the rep gene's original gene, //then we must check to see if it's being recursively duplicated, //and if so check the genetic info to determine how to deal with //the connection bool bFound = false; bool bRecursive = false; if (con.geneID == rep.m_representsID) { //If our gene is the root limb, we're recursing, //and the order of recursion is correct if ((rep.m_parentID != -1) && (rep.m_representsID == m_genome[rep.m_parentID]) && { //It's recursive! bRecursive = true; //If it's recursing from the parent.. if (con.t_rec == TYPE_PARENT) { //.. we've got it! con.geneID = rep.m_parentID; bFound = true; } } //Look through our other representitive genes for (u32 x=0; x < m_genomeRep.size(); ++x) { //Get our reference Gene &reptwo = m_genomeRep.at(x); //If we're the parent, and we both represent the same //heritable gene.. if (reptwo.m_parentID == rep.m_id && reptwo.m_representsID == rep.representsID) { //It's recursive! bRecursive = true; //If it's recursing from the child.. if (con.t_rec == TYPE_CHILD) { //.. we've got it! con.geneID = reptwo.m_id; bFound = true; } } } //If there's definitely a recursion that hasn't been found yet, if (bRecursive && !bFound) { //If it's a self-recursion then it's pretty obvious what to do if (con.t_rec == TYPE_SELF) con.geneID = rep.m_id; bFound = true; } else if (!bFound) { con.geneID = rep.m_id; bFound = true; } } else { //If the connection is from the root gene, and we're not recursive if (con.geneID == 0 && rep.m_representsID != m_genomeRep[rep.m_parentID].m_representsID) { //We don't have to worry about fixing the connection bFound = true; } //If we're the root gene if (rep.m_id == 0) { //Look through all rep genes for (u32 x=0; x < m_genomeRep.size(); ++x) { //Get our reference Gene &reptwo = m_genomeRep.at(x); //If this gene isn't recursed from the parent, // and our connection is represented by him if (reptwo.m_representsID != m_genomeRep[reptwo.m_parentID].m_representsID && con.geneID == reptwo.m_representsID) { //Got it! con.geneID = reptwo.m_id; bFound = true; } } } //If we have a parent, and the neuron connection points to him if (rep.m_parentID != -1 && con.geneID == m_genomeRep[rep.m_parentID].m_representsID) { //Found it con.geneID = rep.m_parentID; bFound = true; } //Look through our other representitive genes for (u32 x=0; x < m_genomeRep.size(); ++x) { //Get our reference Gene &reptwo = m_genomeRep.at(x); //Look for child genes that represent our connection if (reptwo.m_parentID == rep.m_id && con.geneID == reptwo.m_representsID) { //Got it! con.geneID = reptwo.m_id; bFound = true; } } } //Make sure the connection is valid assert(con.geneID != -1, "Unable to find connection's owner gene."); //Have we found the original connector? if (!bFound) //Looks like we'll have to remove him :( neur.m_conns.erase(m_conns[k--]); } } }}//walkGenome - Internal recursive function to walk the genome and construct the representationvoid Creature::walkGenome(s32 idx, s32 parentID, s32 nRecursion, s32 symmetry){ // Construct new representative gene ////////////////////////////////////////////////// Gene limbrep; Gene &parent = m_genomeRep[parentID]; //Populate the new gene limbrep = m_genome.at(idx); limbrep.m_representsID = limbrep.m_id; limbrep.m_parentID = parentID; //If this gene is involved in symmetry if (symmetry) limbrep.symmetrised = 1 - parent.symmetrised; else limbrep.symmetrised = parent.symmetrised; //Flip the emergent angle if (limbrep.symmetrised) limbrep.alpha *= -1; //Is this a recursive gene? if (parent.m_representsID == limbrep.m_id) { //limbrep.alpha = limbrep.alpharec / 4.0; //limbrep.beta = limbrep.betarec / 4.0; limbrep.alpha = limbrep.beta = 0; if (limbrep.symmetrised) limbrep.alpha *= -1; } //We can now add the new representative gene s32 limbID = m_genomeRep.addGene(limbrep); ////////////////////////////////////////////////// // Recurse through child genes ////////////////////////////////////////////////// //Look through the original genome for (u32 i=0; i < m_genome.size(); ++i) { //If gene is a child of this iteration.. Gene &it = m_genome.at(i); if (it.m_parentID == limbrep.m_id && !it.terminal) { //Process it! walkGenome(i, limbID, it.m_recursion, 0); //Draw the reflection too if (it.m_reflection == true) walkGenome(i, limbID, it.m_recursion, 1); } } //Draw our recursions if (nRecursion > 0 && (parentID != -1)) { //Walk it walkGenome(idx, limbID, nRecursion - 1, 0); limbID = m_genomeRep.m_curGeneID - 1; } //Look through the original genome for (u32 i=0; i < m_genome.size(); ++i) { //If gene is a child of this iteration.. Gene &it = m_genome.at(i); if (it.m_parentID == limbrep.m_id && it.terminal && !nRecursion) { //Process it! walkGenome(i, limbID, it.m_recursion, 0); //Draw the reflection too if (it.m_reflection == true) walkGenome(i, limbID, it.m_recursion, 1); } }}