public void RandomVector(ref Vector3 start, ref Vector3 end, float offsetAmount, out Vector3 result)
{
if (orthographic)
{
Vector3 directionNormalized = (end - start).normalized;
Vector3 side = new Vector3(-directionNormalized.y, directionNormalized.x, directionNormalized.z);
//float distance = ((float)RandomGenerator.NextDouble() * offsetAmount * 2.0f) - offsetAmount;
float distance = ((float)BetterRandom.betterRandom(0, 1000000) / 1000000f * offsetAmount * 2.0f) - offsetAmount;
result = side * distance;
}
else
{
Vector3 directionNormalized = (end - start).normalized;
Vector3 side;
GetPerpendicularVector(ref directionNormalized, out side);
// generate random distance
//float distance = (((float)RandomGenerator.NextDouble() + 0.1f) * offsetAmount);
float distance = (((float)BetterRandom.betterRandom(0, 1000000) / 1000000f + 0.1f) * offsetAmount);
// get random rotation angle to rotate around the current direction
//float rotationAngle = ((float)RandomGenerator.NextDouble() * 360.0f);
float rotationAngle = ((float)BetterRandom.betterRandom(0, 1000000) / 1000000f * 360.0f);
// rotate around the direction and then offset by the perpendicular vector
result = Quaternion.AngleAxis(rotationAngle, directionNormalized) * side * distance;
}
}
/// <summary>
/// Get the win condition for current game
/// </summary>
public void GetWinCondition()
{
int requiredEvolvePower = BetterRandom.betterRandom(11, 15);
int powerDifference = 16 - requiredEvolvePower;
int[] targetAbilityPowers = { 4, 4, 4, 4 };
while (powerDifference > 0)
{
int ability = BetterRandom.betterRandom(0, 3);
if (targetAbilityPowers[ability] > 0)
{
targetAbilityPowers[ability]--;
powerDifference--;
}
}
gameGoal.maxHealth = playerUnitInitialMaxHealth + targetAbilityPowers[0];
gameGoal.moveRange = playerUnitInitialMoveRange + targetAbilityPowers[1];
gameGoal.attackPower = playerUnitInitialAttackPower + targetAbilityPowers[2];
gameGoal.attackRange = playerUnitInitialAttackRange + targetAbilityPowers[3];
gameGoal.CreateCloneLook();
gameGoal.health = 0; // Hide health bar
}
public void GeneticCrossOver()
{
if (simManager.genNum == 1) // If this is the first generation
{
return;
}
int[] parentIndexes = SelectParents();
basicLayer = simManager.lastSquares[parentIndexes[0]].basicLayer; // Copy one parent's neural network layer to the new one's
if (basicLayer == null) //parentIndexes[0] < 10)
{
print(parentIndexes[0] + ", " + simManager.lastSquares[parentIndexes[0]].id + ", " + simManager.lastSquares[parentIndexes[0]].basicLayer[0, 0]);
}
for (int i = 0; i < basicLayer.GetLength(0); i++)
{
for (int j = 0; j < basicLayer.GetLength(1); j++)
{
if (BetterRandom.betterRandom(0, 1000000) / 1000000f <= SimulationManager.sCrossOverRate) // Cross over
{
basicLayer[i, j] = simManager.lastSquares[parentIndexes[1]].basicLayer[i, j];
}
}
}
}
/// <summary>
/// Randomly generate a new enemy type with a certain total power
/// 1: move
/// 2: hp
/// 3: power
/// 4: range
/// </summary>
/// <param name="totalPower"></param>
/// <returns></returns>
public EnemyTypeInfo CreateNewEnemyType(int totalPower)
{
EnemyTypeInfo newTypeInfo = new EnemyTypeInfo();
int[] abilityStrength = { maxEnemyMoveRange, maxEnemyMaxHealth, maxEnemyAttackPower, maxEnemyAttackRange };
int[] minAbilityStrength = { minEnemyMoveRange, minEnemyMaxHealth, minEnemyAttackPower, minEnemyAttackRange };
int targetDifference = maxEnemyMoveRange + maxEnemyMaxHealth + maxEnemyAttackPower + maxEnemyAttackRange - totalPower;
// Reduce ability strength to match total power
while (targetDifference > 0)
{
int ability = BetterRandom.betterRandom(0, abilityStrength.Length - 1);
// If strength can be decreased
if (abilityStrength[ability] > minAbilityStrength[ability])
{
abilityStrength[ability]--;
targetDifference--;
}
}
newTypeInfo.moveRange = abilityStrength[0];
newTypeInfo.maxHealth = abilityStrength[1];
newTypeInfo.attackPower = abilityStrength[2];
newTypeInfo.attackRange = abilityStrength[3];
return(newTypeInfo);
}
public void PlaySFXOneShot(AudioClip sfx)
{
sfxPlayer.Stop();
float k = BetterRandom.betterRandom(-100, 100) / 1000;// avoid machine gun sound
sfxPlayer.volume = masterVolume + masterVolume * k;
sfxPlayer.PlayOneShot(sfx);
}
/// <summary>
/// Place down enemy units
/// </summary>
public void PlaceNewEnemies()
{
// Get a list of empty map border tiles
List <GridTileInfo> emptyBorderTiles = MapManager.sMapManager.GetEmptyBorderTiles();
// Get number of enemies to be generated
int maxEnemyAmount = Mathf.Clamp(Mathf.FloorToInt(GameManager.playerTotalPower / EnemyManager.minEnemyPower), 0, emptyBorderTiles.Count);
int minEnemyAmount = Mathf.Clamp(Mathf.CeilToInt(GameManager.playerTotalPower / EnemyManager.maxEnemyPower), 1, maxEnemyAmount); // Make sure there is at least one enemy being generated
int enemyAmount = BetterRandom.betterRandom(minEnemyAmount, maxEnemyAmount);
// Get individual power for each enemy
int[] individualEnemyPower = new int[enemyAmount];
for (int i = 0; i < individualEnemyPower.Length; i++)
{
individualEnemyPower[i] = EnemyManager.maxEnemyPower;
}
int powerDifference = enemyAmount * EnemyManager.maxEnemyPower - GameManager.playerTotalPower; // Get power difference
while (powerDifference > 0) // Randomly decrease enemy power
{
int selectedEnemy = BetterRandom.betterRandom(0, individualEnemyPower.Length - 1); // Randomly select an enemy
// Decrement selected enemy power if it has not reached minEnemyPower
if (individualEnemyPower[selectedEnemy] > EnemyManager.minEnemyPower)
{
individualEnemyPower[selectedEnemy]--;
powerDifference--;
}
}
// Assign spawn positions
List <int> spawnPosition = new List <int>();
for (int i = 0; i < enemyAmount; i++)
{
int newPosition = BetterRandom.betterRandom(0, emptyBorderTiles.Count - 1);
while (spawnPosition.Contains(newPosition))
{
newPosition = BetterRandom.betterRandom(0, emptyBorderTiles.Count - 1);
}
spawnPosition.Add(newPosition);
}
// Create new enemies
for (int i = 0; i < enemyAmount; i++)
{
EnemyManager.sEnemyManager.CreateEnemy(EnemyManager.sEnemyManager.CreateNewEnemyType(individualEnemyPower[i]), emptyBorderTiles[spawnPosition[i]].xCoord, emptyBorderTiles[spawnPosition[i]].zCoord);
}
// Test
//EnemyManager.sEnemyManager.CreateEnemy(EnemyManager.EnemyType.Test, 4, 4);
}
public float[] Noise(float frequency) // Generate a shifted sine wave
{
float[] newWave = new float[actualTerrainSize];
float phaseShift = BetterRandom.betterRandom(0, Mathf.RoundToInt(20000000 * Mathf.PI)) / 10000000f;
for (int i = 0; i < map.GetLength(0); i++)
{
newWave[i] = Mathf.Sin(2 * Mathf.PI * frequency * i / actualTerrainSize + phaseShift);
}
return(newWave);
}
public void Start()
{
offsetX = Random.Range(0, 99999);
offsetY = Random.Range(0, 99999);
Random.InitState(System.DateTime.Now.Millisecond);
randomGradientVector2D = new Vector2[width, height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
//randomGradientVector2D[i, j] = new Vector2(Random.Range(-0.5f, 0.5f), Random.Range(-0.5f, 0.5f));
//print(randomGradientVector2D[i, j]);
do
{
randomGradientVector2D[i, j] = new Vector2(BetterRandom.betterRandom(-50000, 50000) / 100000f, BetterRandom.betterRandom(-50000, 50000) / 100000f);
} while (randomGradientVector2D[i, j].x == 0 || randomGradientVector2D[i, j].y == 0 || randomGradientVector2D[i, j].x == randomGradientVector2D[i, j].y);
}
}
do
{
randomVector = new Vector2(BetterRandom.betterRandom(-10000000, 10000000) / 100000f, BetterRandom.betterRandom(-10000000, 10000000) / 100000f);
} while (randomVector.x == 0 || randomVector.y == 0 || randomVector.x == randomVector.y);
randomSinMulti = BetterRandom.betterRandom(10000, 100000) + (BetterRandom.betterRandom(1000000, 10000000) / 10000000f);
//randomSinMulti = 1;
randomWarpStartCoords = new Vector2[20];
for (int i = 0; i < 10; i++) // Generate random start coorinations for each warping
{
randomWarpStartCoords[i] = new Vector2(BetterRandom.betterRandom(0, 1000) / 100f, BetterRandom.betterRandom(0, 1000) / 100f);
randomWarpStartCoords[i + 10] = new Vector2(BetterRandom.betterRandom(0, 1000) / 100f, BetterRandom.betterRandom(0, 1000) / 100f);
}
terrain = GetComponent <Terrain>(); //for Terrain Data
terrain.terrainData.heightmapResolution = width;
terrain.terrainData.alphamapResolution = width;
terrain.terrainData.size = new Vector3(width, depth, height);
map = new float[width, height]; // Storing the heightmap data (for the noise combination)
if (useAlone)
{
terrain.terrainData = GenerateTerrain(terrain.terrainData);
}
else if (!useAlone)
{
terrain.terrainData = GenerateTerrain(terrain.terrainData);
map = GenerateHeights(); // Storing the heightmap data (for the noise combination)
}
domainWarpingFBM = GetComponent <DomainWarpingFBM>();
}
/// <summary>
/// Set start point and exit point randomly
/// </summary>
private void SetRandomStartAndExit()
{
while (true)
{
startPointXcoord = BetterRandom.betterRandom(0, currentLevel.width - 1);
startPointYcoord = BetterRandom.betterRandom(0, currentLevel.height - 1); //get a random start point
exitPointXcoord = BetterRandom.betterRandom(0, currentLevel.width - 1);
exitPointYcoord = BetterRandom.betterRandom(0, currentLevel.height - 1); //get a random exit point
if (startPointXcoord != exitPointXcoord || startPointYcoord != exitPointYcoord)
{
break;//check if player was born at exit
}
}
}
private void SelectOffsetFromAnimationMode()
{
int index;
if (AnimationMode == LightningBoltAnimationMode.None)
{
lineRenderer.material.mainTextureOffset = offsets[0];
return;
}
else if (AnimationMode == LightningBoltAnimationMode.PingPong)
{
index = animationOffsetIndex;
animationOffsetIndex += animationPingPongDirection;
if (animationOffsetIndex >= offsets.Length)
{
animationOffsetIndex = offsets.Length - 2;
animationPingPongDirection = -1;
}
else if (animationOffsetIndex < 0)
{
animationOffsetIndex = 1;
animationPingPongDirection = 1;
}
}
else if (AnimationMode == LightningBoltAnimationMode.Loop)
{
index = animationOffsetIndex++;
if (animationOffsetIndex >= offsets.Length)
{
animationOffsetIndex = 0;
}
}
else
{
//index = RandomGenerator.Next(0, offsets.Length);
index = BetterRandom.betterRandom(0, offsets.Length);
}
if (index >= 0 && index < offsets.Length)
{
lineRenderer.material.mainTextureOffset = offsets[index];
}
else
{
lineRenderer.material.mainTextureOffset = offsets[0];
}
}
public void GeneticMutation()
{
for (int i = 0; i < basicLayer.GetLength(0); i++)
{
for (int j = 0; j < basicLayer.GetLength(1); j++)
{
if (BetterRandom.betterRandom(0, 100000000) / 100000000f <= SimulationManager.sMutationRate) // Mutate
{
basicLayer[i, j] = BetterRandom.betterRandom(SimulationManager.sMinWeightValue * 10000, SimulationManager.sMaxWeightValue * 10000) / 10000f;
}
else if (simManager.genNum == 1) // If this is the first generation
{
basicLayer[i, j] = BetterRandom.betterRandom(SimulationManager.sMinWeightValue * 10000, SimulationManager.sMaxWeightValue * 10000) / 10000f;
}
}
}
}
public int[] SelectParents()
{
int[] parentIndexes = new int[2]; // Index in square array for parent A and B
float totalFitness = 0;
for (int i = 0; i < simManager.lastSquares.Length; i++) // Add up total fitness
{
totalFitness += simManager.lastSquares[i].fitnessScore;
}
// Select first parent
float parent = BetterRandom.betterRandom(0, Mathf.RoundToInt(totalFitness * 10000)) / 10000f;
float selector = 0;
for (int i = 0; i < simManager.lastSquares.Length; i++)
{
selector += simManager.lastSquares[i].fitnessScore;
if (selector >= parent)
{
parentIndexes[0] = i;
break;
}
}
// Select second parent
parentIndexes[1] = parentIndexes[0];
while (parentIndexes[1] == parentIndexes[0])
{
parent = BetterRandom.betterRandom(0, Mathf.RoundToInt(totalFitness * 10000)) / 10000f;
selector = 0;
for (int i = 0; i < simManager.lastSquares.Length; i++)
{
selector += simManager.lastSquares[i].fitnessScore;
if (selector >= parent)
{
parentIndexes[1] = i;
break;
}
}
}
return(parentIndexes);
}
public void GenerateMap()
{
for (int f = 0; f < frequencies.Length; f++)
{
for (int c = 0; c < counts[f]; c++)
{
float phaseShift = BetterRandom.betterRandom(0, Mathf.RoundToInt(20000000 * Mathf.PI)) / 10000000f;
int centerI = BetterRandom.betterRandom(0, actualTerrainSize - 1);
int centerJ = BetterRandom.betterRandom(0, actualTerrainSize - 1);
for (int i = 0; i < actualTerrainSize; i++)
{
for (int j = 0; j < actualTerrainSize; j++)
{
map[i, j] += (Mathf.Sin(Mathf.Pow(Mathf.Pow(2 * Mathf.PI * frequencies[f] * (i - centerI) / actualTerrainSize + phaseShift, 2) +
Mathf.Pow(2 * Mathf.PI * frequencies[f] * (j - centerJ) / actualTerrainSize + phaseShift, 2), 0.5f)) * amplitudes[f]) / (float)counts[f];
}
}
}
}
for (int i = 0; i < frequencies.Length; i++) // Calculating the scale of the height map
{
heightScale += amplitudes[i]; // * counts[i];
}
for (int i = 0; i < actualTerrainSize; i++) // Normalize height map data to a scale of 1
{
for (int k = 0; k < actualTerrainSize; k++)
{
map[k, i] /= heightScale;
}
}
for (int i = 0; i < actualTerrainSize; i++) // Convert negative value to positive
{
for (int k = 0; k < actualTerrainSize; k++)
{
map[k, i] = Mathf.Abs(map[k, i]);
}
}
}
public void IfMakeNewPlatform() // Should we make new platforms? (new random seed)
{
avgBestTime = 0;
for (int i = 0; i < bestSquares.Length; i++) // Add up best fitness scores
{
avgBestTime += bestSquares[i].timeBeforeDrop;
}
avgBestTime /= (float)bestSquares.Length; // Take the average
if (avgBestTime >= cycleDuration * 0.75f) // If the average fitness score is greater than some value then get new random seed
{
randomSeed = BetterRandom.betterRandom(0, Mathf.RoundToInt(Mathf.Infinity));
Random.InitState(randomSeed);
for (int i = 0; i < bestSquares.Length; i++) // Decrease every best squares' fitness score from the last platform layout
{
bestSquares[i].timeBeforeDrop = 0;
bestSquares[i].fitnessScore *= 0.8f;
}
}
}
public float[,] map; // Storing the heightmap data (for the noise combination)
public void Start()
{
offsetX = Random.Range(0, 99999);
offsetY = Random.Range(0, 99999);
do
{
randomVector2D = new Vector2(BetterRandom.betterRandom(-10000000, 10000000) / 100000f, BetterRandom.betterRandom(-10000000, 10000000) / 100000f);
} while (randomVector2D.x == 0 || randomVector2D.y == 0 || randomVector2D.x == randomVector2D.y);
randomSinMulti = BetterRandom.betterRandom(10000, 100000) + (BetterRandom.betterRandom(1000000, 10000000) / 10000000f);
if (!useAlone)
{
map = new float[width, height]; // Storing the heightmap data (for the noise combination)
map = GenerateHeights(); // Storing the heightmap data (for the noise combination)
Terrain terrain = GetComponent <Terrain>(); //for Terrain Data
terrain.terrainData = GenerateTerrain(terrain.terrainData);
}
}