void Start()
{
playerHealth = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerHealth>();
playerSpawn = GameObject.FindGameObjectWithTag("PlayerSpawn").GetComponent <PlayerReadyManager>();
CurrentGeneration = 1;
GenLogManager.Initialize();
}
/// <summary>
/// Every child is sent here and considered for mutation, they have an x% chance
/// of getting a random trait replaced with a new random one
/// </summary>
/// <param name="child">A newly bred child for the next generation</param>
void ConsiderMutation(StringBuilder child)
{
if (rand.Next(0, 101) <= mutationChance)
{
/*Logging*/
GenLogManager.LogMutatatedIndividual(child.ToString(), afterMutation: false);
int placeToChange;
do
{
placeToChange = rand.Next(0, child.Length);
}while (child[placeToChange] == '|');
char newTrait;
switch (child[placeToChange])
{
case 'h':
case 'd':
case 's':
case 'r':
case 'm':
do
{
newTrait = RandomAttribute;
}while (newTrait == child[placeToChange]);
child[placeToChange] = newTrait;
break;
case 'M':
case 'R':
do
{
newTrait = RandomOffensiveFeature;
}while (newTrait == child[placeToChange]);
child[placeToChange] = newTrait;
break;
case 'B':
case 'D':
do
{
newTrait = RandomDefensiveFeature;
}while (newTrait == child[placeToChange]);
child[placeToChange] = newTrait;
break;
default:
throw new Exception("Tried to mutate unrecognized trait");
}
/*Logging*/
GenLogManager.LogMutatatedIndividual(child.ToString(), afterMutation: true);
}
}
public void CalculateFitnessScore()
{
if (GenerationManager.Tutorial)
{
return;
}
fitnessScore = 0;
fitnessScore += (totalDamage * damageModifier);
fitnessScore += (totalAlmostDamage * almostDamageModifier);
string weaponType;
float distanceBonus = AverageDistance;
if (distanceBonus < 2)
{
distanceBonus = 2;
}
if (distanceBonus > 8)
{
distanceBonus = 8;
}
if (hasMelee && !playerHasMelee)
{
distanceBonus = (8 - distanceBonus);
weaponType = "Melee";
}
else if (!hasMelee && playerHasMelee)
{
distanceBonus = (distanceBonus - 2);
weaponType = "Ranged";
}
else
{
distanceBonus = 3;
weaponType = "Same as player";
}
fitnessScore += distanceBonus * distanceModifier;
fitnessScore += (timeAlive * timeModifier);
GenerationManager.SetFitnessScore(individualNumber, fitnessScore);
//*Logging*//
GenLogManager.LogIndividual(individualNumber, weaponType,
new float[] { totalDamage, damageModifier },
new float[] { totalAlmostDamage, almostDamageModifier },
new float[] { distanceBonus, distanceModifier },
new float[] { timeAlive, timeModifier },
fitnessScore);
}
/// <summary>
/// Breeds a new generation and saves it as a .txt file
/// </summary>
List <string> CreateNextGeneration()
{
/*Logging details about last generation's individuals*/
GenLogManager.SaveLog(LogType.Individual);
List <string> newGeneration = BreedNewGeneration();
GenFilesManager.SaveGeneration(newGeneration);
return(newGeneration);
}
void Start()
{
PlayerReady = true;
if (tutorial)
{
Tutorial = tutorial;
return;
}
else
{
Tutorial = tutorial;
}
playerHealth = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerHealth>();
readyManager = GameObject.FindGameObjectWithTag("ReadyArea").GetComponent <PlayerReadyManager>();
CurrentGeneration = 1;
GenLogManager.Initialize();
}
List <string> RandomizeNextGeneration()
{
/*Logging details about last generation's individuals*/
GenLogManager.SaveLog(LogType.Individual);
List <Individual> sortedList = individuals.OrderByDescending(i => i.FitnessScore).ToList();
/*Logging*/
GenLogManager.LogAfterSort(sortedList);
GenLogManager.LogForGraphing(sortedList);
GenLogManager.SaveLog(LogType.ForGraphing);
List <string> newGeneration = RandomizeGeneration();
/*Logging*/
GenLogManager.LogNewGeneration(newGeneration);
/*Logging*/
GenLogManager.SaveLog(LogType.Progress);
individuals.Clear();
CurrentGeneration++;
return(newGeneration);
}
/// <summary>
/// Looks at the top half of the fitness-scores from the last generation and uses
/// a single point crossover to create a new generation
/// </summary>
List <string> BreedNewGeneration()
{
List <Individual> sortedList = individuals.OrderByDescending(i => i.FitnessScore).ToList();
/*Logging*/
GenLogManager.LogAfterSort(sortedList);
GenLogManager.LogForGraphing(sortedList);
GenLogManager.SaveLog(LogType.ForGraphing);
List <string> newGeneration = new List <string>();
List <string> newAttributes = new List <string>();
List <string> newFeatures = new List <string>();
for (int i = 0; i < sortedList.Count / 2; i++)
{
newGeneration.Add(sortedList[i].Traits);
string[] traits = sortedList[i].Traits.Split('|');
newAttributes.Add(traits[0]);
newFeatures.Add(traits[1]);
}
/*Logging*/
GenLogManager.LogParentsToBreed(newAttributes, newFeatures);
int numberOfParents = newAttributes.Count;
for (int indexParentA = 0; indexParentA < numberOfParents; indexParentA += 2)
{
int indexParentB = indexParentA + 1;
StringBuilder newChildA = new StringBuilder();
StringBuilder newChildB = new StringBuilder();
// Uniform crossover
for (int indexParentTrait = 0; indexParentTrait < Attributes; indexParentTrait++)
{
int coinFlip = rand.Next(0, 2);
if (coinFlip == 0)
{
newChildA.Append(newAttributes[indexParentA][indexParentTrait]);
newChildB.Append(newAttributes[indexParentB][indexParentTrait]);
}
else
{
newChildA.Append(newAttributes[indexParentB][indexParentTrait]);
newChildB.Append(newAttributes[indexParentA][indexParentTrait]);
}
}
newChildA.Append('|');
newChildB.Append('|');
// Uniform crossover
for (int i = 0; i < 2; i++)
{
int coinToss = rand.Next(0, 2);
if (coinToss == 0)
{
newChildA.Append(newFeatures[indexParentA][i]);
newChildB.Append(newFeatures[indexParentB][i]);
}
else
{
newChildA.Append(newFeatures[indexParentB][i]);
newChildB.Append(newFeatures[indexParentA][i]);
}
}
ConsiderMutation(newChildA);
ConsiderMutation(newChildB);
// If any of the children are identical to any of the parents; redo the crossover
if (newChildA.ToString() == newGeneration[indexParentA] ||
newChildA.ToString() == newGeneration[indexParentB])
{
GenLogManager.LogReBreed(newChildA.ToString());
indexParentA -= 2;
continue;
}
else if (newChildB.ToString() == newGeneration[indexParentA] ||
newChildB.ToString() == newGeneration[indexParentB])
{
GenLogManager.LogReBreed(newChildB.ToString());
indexParentA -= 2;
continue;
}
newGeneration.Add(newChildA.ToString());
newGeneration.Add(newChildB.ToString());
}
newGeneration.Add(RandomizeIndividual());
/*Logging*/
GenLogManager.LogNewGeneration(newGeneration);
List <string> shuffledGeneration = newGeneration.OrderBy(x => UnityEngine.Random.value).ToList();
/*Logging*/
GenLogManager.LogNewGeneration(shuffledGeneration);
/*Logging*/
GenLogManager.SaveLog(LogType.Progress);
individuals.Clear();
CurrentGeneration++;
return(shuffledGeneration);
}
void Update()
{
if (tutorial)
{
return;
}
if (CurrentGeneration > TotalGenerations)
{
GenLogManager.LogForGraphing(individuals);
GenLogManager.SaveLog(LogType.Individual);
endText.SetActive(true);
readyManager.End();
gameEnd = true;
}
if (gameEnd)
{
if (Input.GetKeyDown(KeyCode.Escape) || Input.GetButtonDown("Confirm"))
{
if (RandomMode)
{
Application.Quit();
}
else
{
RandomMode = true;
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);
}
}
return;
}
if (playerHealth.IsDead && PlayerReady)
{
ResetWave();
}
else if (playerHealth.IsDead && !PlayerReady)
{
readyManager.NewWave(dead: true);
return;
}
else if (!PlayerReady)
{
return;
}
if (!gameStarted)
{
if (RandomMode)
{
individuals = StringsToIndividuals(RandomizeGeneration());
}
else
{
individuals = StringsToIndividuals(CreateFirstGeneration());
}
ResetVariables();
gameStarted = true;
PlayerReady = false;
readyManager.NewWave();
return;
}
else if (InstantiatedIndividuals >= GenerationSize &&
DeadIndividuals >= GenerationSize &&
CurrentGeneration <= TotalGenerations)
{
if (RandomMode)
{
individuals = StringsToIndividuals(RandomizeNextGeneration());
}
else
{
individuals = StringsToIndividuals(CreateNextGeneration());
}
ResetVariables();
PlayerReady = false;
readyManager.NewWave();
return;
}
spawnTimer += Time.deltaTime;
if (InstantiatedIndividuals - DeadIndividuals <= 0)
{
spawnTimer = spawnFrequency;
}
if (spawnTimer >= spawnFrequency)
{
if ((InstantiatedIndividuals - DeadIndividuals < ConcurrentIndividuals) &&
(InstantiatedIndividuals < GenerationSize) &&
(CurrentGeneration <= TotalGenerations))
{
spawnTimer = 0;
Spawn();
}
}
}
