public override object Read(ES2Reader reader)
{
FitnessComponentData data = new FitnessComponentData();
Read(reader, data);
return(data);
}
public override void Write(object obj, ES2Writer writer)
{
FitnessComponentData data = (FitnessComponentData)obj;
// Add your writer.Write calls here.
writer.Write(0); // Version 1 is current version number
// Make sure to edit Read() function to properly handle version control!
// VERSION 0:
writer.Write(data.agentDataArray);
writer.Write(data.highestScore);
writer.Write(data.lowestScore);
writer.Write(data.totalRawScore);
}
public override void Read(ES2Reader reader, object c)
{
FitnessComponentData data = (FitnessComponentData)c;
// Add your reader.Read calls here to read the data into the object.
// Read the version number.
int fileVersion = reader.Read <int>();
// VERSION 0:
if (fileVersion >= 0)
{
data.agentDataArray = reader.ReadArray <AgentData>();
data.highestScore = reader.Read <float>();
data.lowestScore = reader.Read <float>();
data.totalRawScore = reader.Read <float>();
if (fileVersion >= 1)
{
// new attributes
}
}
}
//
public void InitializeNewGenerationDataArrays(int generationIndex)
{
if (recordScoresTrialDataArray == null) // if first time:
// USE THIS STUFF TO STORE GLOBAL RECORD SCORES PER-FITNESSCOMPONENT!!!
// This will then be used to help score each generation in the future
// I'm just re-using the data classes here but this might need a more custom solution later.
// as with the rest of this system, it can't handle drastic changes to number/type of Trials, or adding/deleting fitness components.
// Eventually I'll have to build a very flexible system that can handle gen0 being totally different from currentGen....
{
recordScoresTrialDataArray = new List <TrialData>();
int numActiveTrials = 0;
for (int i = 0; i < playerRef.masterTrialsList.Count; i++) // First loop needed just to Count
{
if (playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) // if active trial
{
numActiveTrials++;
}
}
// Loop through all Trials:
for (int trialIndex = 0; trialIndex < numActiveTrials; trialIndex++)
{
// Get numFitnessComponents:
int numFitnessComponents = playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList.Count;
TrialData newTrialData = new TrialData(numFitnessComponents);
for (int fitCompIndex = 0; fitCompIndex < numFitnessComponents; fitCompIndex++)
{
FitnessComponentData newFitnessComponentData = new FitnessComponentData();
newTrialData.fitnessComponentDataArray[fitCompIndex] = newFitnessComponentData;
}
recordScoresTrialDataArray.Add(newTrialData);
}
}
// For This Player:
if (generationIndex >= generationDataList.Count) // if new generation needs to be created
// !!!!!!!@!@!#$!@$#!$!@@@@@@@@@@@@@@@@@@@@@@@!@$#!#############!!!!!!!!!!!!!!!!!!!!!!^^^^^^^^^^^^^$%&###############%***********************$$$$$$$$##########
// Calculate total TrialWeights and totalFitnessComponentWeights per Trial for later use somewhere in this function!!!!
{
int numAgents = playerRef.masterPopulation.populationMaxSize;
// Get number of Trials:
int numActiveTrials = 0;
for (int i = 0; i < playerRef.masterTrialsList.Count; i++) // First loop needed just to Count
{
if (playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) // if active trial
{
numActiveTrials++;
}
}
GenerationData newGenerationData = new GenerationData(numActiveTrials);
// Loop through all Trials:
for (int trialIndex = 0; trialIndex < numActiveTrials; trialIndex++)
{
// Get numFitnessComponents:
int numFitnessComponents = playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList.Count;
TrialData newTrialData = new TrialData(numFitnessComponents);
for (int fitCompIndex = 0; fitCompIndex < numFitnessComponents; fitCompIndex++)
{
FitnessComponentData newFitnessComponentData = new FitnessComponentData(numAgents);
for (int a = 0; a < numAgents; a++)
{
AgentData newAgentData = new AgentData();
newFitnessComponentData.agentDataArray[a] = newAgentData;
}
newTrialData.totalSumOfWeights += playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList[fitCompIndex].weight;
newTrialData.fitnessComponentDataArray[fitCompIndex] = newFitnessComponentData;
}
newGenerationData.totalSumOfWeights += playerRef.masterTrialsList[trialIndex].weight;
newGenerationData.trialDataArray[trialIndex] = newTrialData; // actually assign the new AgentData instance to generationData
newGenerationData.totalNumFitnessComponents = numFitnessComponents;
}
// AvgGenome:
// Calculate Generation average genome: // BROKEN BECAUSE USING NEW GENOMES!!!
/*Genome avgGenome = new Genome();
* avgGenome.genomeBiases = new float[playerRef.masterPopulation.masterAgentArray[0].genome.genomeBiases.Length];
* avgGenome.genomeWeights = new float[playerRef.masterPopulation.masterAgentArray[0].genome.genomeWeights.Length];
* avgGenome.ZeroGenome(); // set all values to 0f;
* for (int i = 0; i < numAgents; i++) {
* // iterate through Bias Arrays and add each agent's bias value to the avg
* for (int b = 0; b < avgGenome.genomeBiases.Length; b++) {
* avgGenome.genomeBiases[b] += playerRef.masterPopulation.masterAgentArray[i].genome.genomeBiases[b] / (float)numAgents;
* }
* // iterate through Weight Arrays and add each agent's weight value to the avg
* for (int w = 0; w < avgGenome.genomeWeights.Length; w++) {
* avgGenome.genomeWeights[w] += playerRef.masterPopulation.masterAgentArray[i].genome.genomeWeights[w] / (float)numAgents;
* }
* }
* // Save the genome values to this generation Data:
* newGenerationData.genAvgGenome = avgGenome;*/
//newGenerationData.genAvgGenome.genomeBiases = avgGenome.genomeBiases;
//newGenerationData.genAvgGenome.genomeWeights = avgGenome.genomeWeights;
generationDataList.Add(newGenerationData); // Add the newly created generation data to the master list
// OLD BELOW v v v v v v v v v v v v
// Loop over all agents
/*int numAgents = playerRef.masterPopulation.populationMaxSize;
* for (int j = 0; j < numAgents; j++) {
* AgentData newAgentData = new AgentData(numActiveTrials);
*
* // Fill the AgentData's TrialsList:
* int curTrialIndex = 0;
* int totalNumComponents = 0;
* for(int i = 0; i < playerRef.masterTrialsList.Count; i++) {
* if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) { // if active trial
* // For each Trial, Get number of FitnessComponents & GameRounds
* int numGameRounds = playerRef.masterTrialsList[i].numberOfPlays;
* int totalFitnessComponents = playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count +
* playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count;
* int numActiveFitnessComponents = 0;
* // Brain Components:
* for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
* if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
* numActiveFitnessComponents++;
* totalNumComponents++;
* }
* }
* // Game Components:
* for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
* if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
* numActiveFitnessComponents++;
* totalNumComponents++;
* }
* }
*
* int curFitnessComponentIndex = 0;
* TrialData newTrialData = new TrialData(numActiveFitnessComponents);
* for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
* if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
* newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
* curFitnessComponentIndex++;
* }
* }
* for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
* if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
* newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
* curFitnessComponentIndex++;
* }
* }
* newAgentData.trialDataArray[curTrialIndex] = newTrialData; // Set AgentData for this agent.
* //Debug.Log ("curTrialIndex= " + curTrialIndex.ToString() + ", numGameRounds= " + numGameRounds.ToString() + ", numFitnessComponents= " + totalFitnessComponents.ToString() + ", numActiveFitnessComponents= " + numActiveFitnessComponents.ToString());
* curTrialIndex++; // before or after?
*
* }
* }
* newGenerationData.agentDataArray[j] = newAgentData; // actually assign the new AgentData instance to generationData
* newGenerationData.totalNumFitnessComponents = totalNumComponents;
* }
* //
* generationDataList.Add (newGenerationData); // Add the newly created generation data to the master list
*/
}
}
public override object Read(ES2Reader reader)
{
FitnessComponentData data = new FitnessComponentData();
Read(reader, data);
return data;
}
public void UpdateDataText()
{
textPageTitle.text = currentPage.ToString();
if (currentAgent >= populationRef.masterAgentArray.Length)
{
currentAgent = 0;
}
if (currentAgent < 0)
{
currentAgent = populationRef.masterAgentArray.Length - 1;
}
numAgents = populationRef.masterAgentArray.Length;
string bodyText = "";
switch (currentPage)
{
case CurrentPage.EachAgentBrain:
//+++++++++++++++++++++ EachAgentBrain ++++++++++++++++++++++++++++++++++++++++
Agent sourceAgent = populationRef.masterAgentArray[currentAgent];
// Intro Info:
bodyText += "Agent #" + currentAgent.ToString() + ", speciesID: " + sourceAgent.speciesID.ToString() + "\n";
// High-level stats:
bodyText += sourceAgent.brain.neuronList.Count.ToString() + " nodes, " + sourceAgent.brain.connectionList.Count + " connections\n";
// Go through all nodes:
int curInput = 0;
int curOutput = 0;
for (int n = 0; n < sourceAgent.brain.neuronList.Count; n++)
{
string neuronName = "";
if (sourceAgent.brain.neuronList[n].nodeType == GeneNodeNEAT.GeneNodeType.In)
{
if (curInput < minigameRef.inputChannelsList.Count)
{
neuronName += minigameRef.inputChannelsList[curInput].channelName;
curInput++;
}
}
if (sourceAgent.brain.neuronList[n].nodeType == GeneNodeNEAT.GeneNodeType.Out)
{
if (curOutput < minigameRef.outputChannelsList.Count)
{
neuronName += minigameRef.outputChannelsList[curOutput].channelName;
curOutput++;
}
}
bodyText += "Neuron #" + n.ToString() + " (" + sourceAgent.brain.neuronList[n].nodeType.ToString() + " - " + neuronName + ") f: " + sourceAgent.brain.neuronList[n].activationFunction.ToString() + " " + sourceAgent.brainGenome.nodeNEATList[n].id.ToString() + ", pVal: "
+ sourceAgent.brain.neuronList[n].previousValue.ToString() + ", curVal: " + sourceAgent.brain.neuronList[n].currentValue[0].ToString() + "\n";
}
// Go through all Connections:
for (int c = 0; c < sourceAgent.brain.connectionList.Count; c++)
{
bodyText += "Connection #" + c.ToString() + ", From: " + sourceAgent.brain.connectionList[c].fromNodeID.ToString() + ", To: "
+ sourceAgent.brain.connectionList[c].toNodeID.ToString() + ", Weight: " + sourceAgent.brain.connectionList[c].weight[0].ToString() + "\n";
}
break;
case CurrentPage.EachAgentBrainConnections:
//+++++++++++++++++++++ EachAgentBrainConnections ++++++++++++++++++++++++++++++++++++++++
sourceAgent = populationRef.masterAgentArray[currentAgent];
// Intro Info:
bodyText += "Agent #" + currentAgent.ToString() + ", speciesID: " + sourceAgent.speciesID.ToString() + "\n";
// High-level stats:
bodyText += sourceAgent.brain.neuronList.Count.ToString() + " nodes, " + sourceAgent.brain.connectionList.Count + " connections\n";
// Go through all Connections:
for (int c = 0; c < sourceAgent.brain.connectionList.Count; c++)
{
bodyText += "Connection #" + c.ToString() + ", From: " + sourceAgent.brain.connectionList[c].fromNodeID.ToString() + ", To: "
+ sourceAgent.brain.connectionList[c].toNodeID.ToString() + ", Weight: " + sourceAgent.brain.connectionList[c].weight[0].ToString() + "\n";
}
break;
case CurrentPage.GeneLinks:
//populationRef.geneHistoryDict
bodyText += "GENE LINKS" + "\n";
if (populationRef.geneHistoryDict != null)
{
int failsafe = 0;
var enumerator = populationRef.geneHistoryDict.GetEnumerator();
while (enumerator.MoveNext())
{
// Access value with enumerator.Current.Value;
//bodyText += enumerator.Current.Value.ToString() + "\n";
GeneHistoryInfo geneLink = enumerator.Current.Value;
bodyText += "Gene Link #" + geneLink.innov.ToString() + " numCopies: " + geneLink.numCopies.ToString() + ", from: " + geneLink.fromNode.ToString() + ", to: " + geneLink.toNode.ToString() + ", gen: " + geneLink.gen.ToString() + ", avgWeight: " + geneLink.avgWeight.ToString() + "\n";
failsafe++;
if (failsafe > 5000)
{
break;
}
}
}
else
{
bodyText += "Dict = NULL!";
}
break;
case CurrentPage.AllAgentsBrains:
//+++++++++++++++++++++ AllAgentsBrains ++++++++++++++++++++++++++++++++++++++++
// Intro Info:
bodyText += populationRef.masterAgentArray.Length.ToString() + " Agents\n";
for (int a = 0; a < populationRef.masterAgentArray.Length; a++)
{
bodyText += "Agent #" + a.ToString();
int numNodes = populationRef.masterAgentArray[a].brain.neuronList.Count;
int numInputNodes = populationRef.masterAgentArray[a].brain.inputNeuronList.Count;
int numOutputNodes = populationRef.masterAgentArray[a].brain.outputNeuronList.Count;
int numHiddenNodes = numNodes - numInputNodes - numOutputNodes;
int numConnections = populationRef.masterAgentArray[a].brain.connectionList.Count;
bodyText += ": TotalNodes: " + numNodes.ToString() + " InNodes: " + numInputNodes.ToString() + ", OutNodes: " + numOutputNodes.ToString() + ", HidNodes: " + numHiddenNodes.ToString() + ", Links: " + numConnections.ToString() + ", sID: " + populationRef.masterAgentArray[a].speciesID.ToString() + "\n";
}
break;
case CurrentPage.BrainGenome:
//+++++++++++++++++++++ BrainGenome ++++++++++++++++++++++++++++++++++++++++
sourceAgent = populationRef.masterAgentArray[currentAgent];
// Intro Info:
bodyText += "Agent #" + currentAgent.ToString() + ", speciesID: " + sourceAgent.speciesID.ToString() + "\n";
// High-level stats:
bodyText += sourceAgent.brainGenome.nodeNEATList.Count.ToString() + " nodes, " + sourceAgent.brainGenome.linkNEATList.Count + " links\n";
bodyText += sourceAgent.brain.neuronList.Count.ToString() + " neurons, " + sourceAgent.brain.connectionList.Count + " connections\n";
// Go through all Connections:
for (int c = 0; c < sourceAgent.brainGenome.nodeNEATList.Count; c++)
{
bodyText += "Node #" + c.ToString() + ", ID: " + sourceAgent.brainGenome.nodeNEATList[c].id.ToString() + " " + new Int3(sourceAgent.brainGenome.nodeNEATList[c].sourceAddonInno, sourceAgent.brainGenome.nodeNEATList[c].sourceAddonRecursionNum, sourceAgent.brainGenome.nodeNEATList[c].sourceAddonChannelNum).ToString() + ", Type: "
+ sourceAgent.brainGenome.nodeNEATList[c].nodeType + ", Activation: " + sourceAgent.brainGenome.nodeNEATList[c].activationFunction.ToString() + "\n";
}
for (int c = 0; c < sourceAgent.brainGenome.linkNEATList.Count; c++)
{
bodyText += "Link #" + c.ToString() + ", inno: " + sourceAgent.brainGenome.linkNEATList[c].innov.ToString() + ", active: " + sourceAgent.brainGenome.linkNEATList[c].enabled.ToString() + ", From: "
+ sourceAgent.brainGenome.linkNEATList[c].fromNodeID.ToString() + ", To: " + sourceAgent.brainGenome.linkNEATList[c].toNodeID.ToString() + ", weight: " + sourceAgent.brainGenome.linkNEATList[c].weight.ToString() + "\n";
}
break;
case CurrentPage.BodyGenome:
//+++++++++++++++++++++ BodyGenome ++++++++++++++++++++++++++++++++++++++++
sourceAgent = populationRef.masterAgentArray[currentAgent];
// Intro Info:
bodyText += "Agent #" + currentAgent.ToString() + ", speciesID: " + sourceAgent.speciesID.ToString() + " #Nodes: " + sourceAgent.bodyGenome.CritterNodeList.Count.ToString() + "\n";
// High-level stats:
// Go through all Connections:
for (int c = 0; c < sourceAgent.bodyGenome.CritterNodeList.Count; c++)
{
bodyText += "Node #" + c.ToString() + ", Inno: " + sourceAgent.bodyGenome.CritterNodeList[c].innov.ToString() + ", ParentNode: " + sourceAgent.bodyGenome.CritterNodeList[c].jointLink.parentNodeID.ToString() + "\n";
}
break;
case CurrentPage.FitnessRealtime:
//+++++++++++++++++++++ EachAgentFitnessLive ++++++++++++++++++++++++++++++++++++++++
// Intro Info:
bodyText += minigameRef.fitnessComponentList.Count + " Fitness Components:\n";
for (int f = 0; f < minigameRef.fitnessComponentList.Count; f++)
{
float score = minigameRef.fitnessComponentList[f].componentScore[0];
if (minigameRef.gameCurrentTimeStep > 0)
{
if (minigameRef.fitnessComponentList[f].divideByTimeSteps)
{
score /= ((float)minigameRef.gameCurrentTimeStep + 1f);
}
}
bodyText += minigameRef.fitnessComponentList[f].componentName + ": " + score.ToString() + "\n";
}
break;
case CurrentPage.EachAgentFitnessPrev:
//+++++++++++++++++++++ EachAgentFitnessPrev ++++++++++++++++++++++++++++++++++++++++
if (dataManagerRef.generationDataList.Count >= 2)
{
int fitCompLength = dataManagerRef.generationDataList[dataManagerRef.generationDataList.Count - 1].trialDataArray[0].fitnessComponentDataArray.Length;
bodyText += "Agent #" + currentAgent.ToString() + ":\n";
for (int f = 0; f < fitCompLength; f++)
{
FitnessComponentData fitData = dataManagerRef.generationDataList[dataManagerRef.generationDataList.Count - 2].trialDataArray[0].fitnessComponentDataArray[f];
bodyText += minigameRef.fitnessComponentList[f].componentName + " rawValueTotal: " + fitData.agentDataArray[currentAgent].rawValueTotal.ToString() + "\n";
}
}
break;
case CurrentPage.AllAgentsFitnessPrev:
//+++++++++++++++++++++ AllAgentsFitnessPrev ++++++++++++++++++++++++++++++++++++++++
if (dataManagerRef.generationDataList.Count >= 2)
{
int fitCompLength = dataManagerRef.generationDataList[dataManagerRef.generationDataList.Count - 1].trialDataArray[0].fitnessComponentDataArray.Length;
//bodyText += "Agent #" + currentAgent.ToString() + ":\n";
//List<float> agentFitCompList = new List<float>();
for (int f = 0; f < fitCompLength; f++)
{
float fitCompTotal = 0f;
for (int a = 0; a < numAgents; a++)
{
FitnessComponentData fitData = dataManagerRef.generationDataList[dataManagerRef.generationDataList.Count - 2].trialDataArray[0].fitnessComponentDataArray[f];
fitCompTotal += fitData.agentDataArray[a].rawValueTotal;
}
bodyText += minigameRef.fitnessComponentList[f].componentName + " rawValueTotal: " + fitCompTotal.ToString() + "\n";
}
}
break;
case CurrentPage.AllAgentsFitnessPrevNormalized:
//+++++++++++++++++++++ AllAgentsFitnessPrevNormalized ++++++++++++++++++++++++++++++++++++++++
if (dataManagerRef.generationDataList.Count >= 2)
{
for (int a = 0; a < numAgents; a++)
{
bodyText += "Agent #" + a.ToString() + " Fitness Score: " + populationRef.masterAgentArray[a].parentFitnessScoreA + "\n";
}
}
break;
case CurrentPage.SpeciesFitness:
//+++++++++++++++++++++ SpeciesFitness ++++++++++++++++++++++++++++++++++++++++
for (int i = 0; i < populationRef.speciesBreedingPoolList.Count; i++)
{
bodyText += "Species #: " + populationRef.speciesBreedingPoolList[i].speciesID.ToString() + ", SpeciesSize: " + populationRef.speciesBreedingPoolList[i].agentList.Count.ToString() + " Avg Fitness: ";
if (populationRef.speciesBreedingPoolList[i].agentList.Count > 0)
{
float speciesAvgFitness = 0f;
for (int j = 0; j < populationRef.speciesBreedingPoolList[i].agentList.Count; j++)
{
speciesAvgFitness += populationRef.speciesBreedingPoolList[i].agentList[j].parentFitnessScoreA;
}
speciesAvgFitness /= populationRef.speciesBreedingPoolList[i].agentList.Count;
bodyText += speciesAvgFitness.ToString() + "\n";
}
else
{
bodyText += "(((EXTINCT)))\n";
}
}
break;
default:
Debug.Log("Page type not found!!!");
break;
}
// Apply to textField:
textBox.text = bodyText;
}
//
public void InitializeNewGenerationDataArrays(int generationIndex) {
if (recordScoresTrialDataArray == null) { // if first time:
// USE THIS STUFF TO STORE GLOBAL RECORD SCORES PER-FITNESSCOMPONENT!!!
// This will then be used to help score each generation in the future
// I'm just re-using the data classes here but this might need a more custom solution later.
// as with the rest of this system, it can't handle drastic changes to number/type of Trials, or adding/deleting fitness components.
// Eventually I'll have to build a very flexible system that can handle gen0 being totally different from currentGen....
recordScoresTrialDataArray = new List<TrialData>();
int numActiveTrials = 0;
for (int i = 0; i < playerRef.masterTrialsList.Count; i++) { // First loop needed just to Count
if (playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) { // if active trial
numActiveTrials++;
}
}
// Loop through all Trials:
for (int trialIndex = 0; trialIndex < numActiveTrials; trialIndex++) {
// Get numFitnessComponents:
int numFitnessComponents = playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList.Count;
TrialData newTrialData = new TrialData(numFitnessComponents);
for (int fitCompIndex = 0; fitCompIndex < numFitnessComponents; fitCompIndex++) {
FitnessComponentData newFitnessComponentData = new FitnessComponentData();
newTrialData.fitnessComponentDataArray[fitCompIndex] = newFitnessComponentData;
}
recordScoresTrialDataArray.Add(newTrialData);
}
}
// For This Player:
if(generationIndex >= generationDataList.Count) { // if new generation needs to be created
// !!!!!!!@!@!#$!@$#!$!@@@@@@@@@@@@@@@@@@@@@@@!@$#!#############!!!!!!!!!!!!!!!!!!!!!!^^^^^^^^^^^^^$%&###############%***********************$$$$$$$$##########
// Calculate total TrialWeights and totalFitnessComponentWeights per Trial for later use somewhere in this function!!!!
int numAgents = playerRef.masterPopulation.populationMaxSize;
// Get number of Trials:
int numActiveTrials = 0;
for(int i = 0; i < playerRef.masterTrialsList.Count; i++) { // First loop needed just to Count
if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) { // if active trial
numActiveTrials++;
}
}
GenerationData newGenerationData = new GenerationData(numActiveTrials);
// Loop through all Trials:
for(int trialIndex = 0; trialIndex < numActiveTrials; trialIndex++) {
// Get numFitnessComponents:
int numFitnessComponents = playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList.Count;
TrialData newTrialData = new TrialData(numFitnessComponents);
for(int fitCompIndex = 0; fitCompIndex < numFitnessComponents; fitCompIndex++) {
FitnessComponentData newFitnessComponentData = new FitnessComponentData(numAgents);
for(int a = 0; a < numAgents; a++) {
AgentData newAgentData = new AgentData();
newFitnessComponentData.agentDataArray[a] = newAgentData;
}
newTrialData.totalSumOfWeights += playerRef.masterTrialsList[trialIndex].fitnessManager.masterFitnessCompList[fitCompIndex].weight;
newTrialData.fitnessComponentDataArray[fitCompIndex] = newFitnessComponentData;
}
newGenerationData.totalSumOfWeights += playerRef.masterTrialsList[trialIndex].weight;
newGenerationData.trialDataArray[trialIndex] = newTrialData; // actually assign the new AgentData instance to generationData
newGenerationData.totalNumFitnessComponents = numFitnessComponents;
}
// AvgGenome:
// Calculate Generation average genome: // BROKEN BECAUSE USING NEW GENOMES!!!
/*Genome avgGenome = new Genome();
avgGenome.genomeBiases = new float[playerRef.masterPopulation.masterAgentArray[0].genome.genomeBiases.Length];
avgGenome.genomeWeights = new float[playerRef.masterPopulation.masterAgentArray[0].genome.genomeWeights.Length];
avgGenome.ZeroGenome(); // set all values to 0f;
for (int i = 0; i < numAgents; i++) {
// iterate through Bias Arrays and add each agent's bias value to the avg
for (int b = 0; b < avgGenome.genomeBiases.Length; b++) {
avgGenome.genomeBiases[b] += playerRef.masterPopulation.masterAgentArray[i].genome.genomeBiases[b] / (float)numAgents;
}
// iterate through Weight Arrays and add each agent's weight value to the avg
for (int w = 0; w < avgGenome.genomeWeights.Length; w++) {
avgGenome.genomeWeights[w] += playerRef.masterPopulation.masterAgentArray[i].genome.genomeWeights[w] / (float)numAgents;
}
}
// Save the genome values to this generation Data:
newGenerationData.genAvgGenome = avgGenome;*/
//newGenerationData.genAvgGenome.genomeBiases = avgGenome.genomeBiases;
//newGenerationData.genAvgGenome.genomeWeights = avgGenome.genomeWeights;
generationDataList.Add(newGenerationData); // Add the newly created generation data to the master list
// OLD BELOW v v v v v v v v v v v v
// Loop over all agents
/*int numAgents = playerRef.masterPopulation.populationMaxSize;
for (int j = 0; j < numAgents; j++) {
AgentData newAgentData = new AgentData(numActiveTrials);
// Fill the AgentData's TrialsList:
int curTrialIndex = 0;
int totalNumComponents = 0;
for(int i = 0; i < playerRef.masterTrialsList.Count; i++) {
if(playerRef.masterTrialsList[i].miniGameManager.gameType != MiniGameManager.MiniGameType.None) { // if active trial
// For each Trial, Get number of FitnessComponents & GameRounds
int numGameRounds = playerRef.masterTrialsList[i].numberOfPlays;
int totalFitnessComponents = playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count +
playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count;
int numActiveFitnessComponents = 0;
// Brain Components:
for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
numActiveFitnessComponents++;
totalNumComponents++;
}
}
// Game Components:
for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
numActiveFitnessComponents++;
totalNumComponents++;
}
}
int curFitnessComponentIndex = 0;
TrialData newTrialData = new TrialData(numActiveFitnessComponents);
for(int b = 0; b < playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList.Count; b++) {
if(playerRef.masterTrialsList[i].fitnessManager.brainFitnessComponentList[b].on) {
newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
curFitnessComponentIndex++;
}
}
for(int g = 0; g < playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList.Count; g++) {
if(playerRef.masterTrialsList[i].fitnessManager.gameFitnessComponentList[g].on) {
newTrialData.fitnessComponentDataArray[curFitnessComponentIndex] = new FitnessComponentData(numGameRounds);
curFitnessComponentIndex++;
}
}
newAgentData.trialDataArray[curTrialIndex] = newTrialData; // Set AgentData for this agent.
//Debug.Log ("curTrialIndex= " + curTrialIndex.ToString() + ", numGameRounds= " + numGameRounds.ToString() + ", numFitnessComponents= " + totalFitnessComponents.ToString() + ", numActiveFitnessComponents= " + numActiveFitnessComponents.ToString());
curTrialIndex++; // before or after?
}
}
newGenerationData.agentDataArray[j] = newAgentData; // actually assign the new AgentData instance to generationData
newGenerationData.totalNumFitnessComponents = totalNumComponents;
}
//
generationDataList.Add (newGenerationData); // Add the newly created generation data to the master list
*/
}
}
