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); } }