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];
}
}
}
}
public string ThrowGrenade()
{
var eligableHalls = _halls.Where(hall => !hall.PartOfTree && !hall.IsDestroyed).ToList();
if (!eligableHalls.Any())
{
return("You fear the whole dungeon would collapse if you threw another grenade.");
}
var destroyed = 0;
while (destroyed < Math.Min(15, eligableHalls.Count) && eligableHalls.Count > 0)
{
var index = new BetterRandom().Next(eligableHalls.Count);
eligableHalls[index].IsDestroyed = true;
eligableHalls.RemoveAt(index);
destroyed++;
}
// Kill enemy
Player.Position.Enemy = null;
DrawCompassRoute();
return("You hear a trembling in the distance, a part of the dungeon has collapsed.");
}
/// <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);
}
private double GetRandomGen()
{
BetterRandom random = new BetterRandom();
return(random.Range(genMin, genMax));
//return Random.Range(genMin, genMax);
}
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;
}
}
public ActionResult CreateRandomOrder(OrderInfoDTO orderInfoDTO)
{
IRestResponse <OrderResponseDTO> response = null;
var toppings = _distributedPizzaDbContext.Toppings.ToList();
BetterRandom random = new BetterRandom();
for (int i = 0; i < orderInfoDTO.NumberOfRequests; i++)
{
var orderManager = new OrderManager(toppings, random);
var order = orderManager.GenerateRandomOrder();
order.QueueType = orderInfoDTO.QueueType;
order.ReportBackToClient = orderInfoDTO.NumberOfRequests == 1;
var client = new RestClient("http://localhost/DistributedPizza.Web.Api");
var request = new RestRequest("api/orders/create", Method.POST);
request.AddHeader("Accept", "application/json");
request.RequestFormat = DataFormat.Json;
request.AddBody(order);
response = client.Execute <OrderResponseDTO>(request);
}
if (orderInfoDTO.NumberOfRequests == 1 & response != null)
{
response.Data.NumberOfRequests = orderInfoDTO.NumberOfRequests;
return(Json(response.Data));
}
else
{
return(Json(new OrderResponseDTO {
NumberOfRequests = orderInfoDTO.NumberOfRequests
}));
}
}
public static double RandomNext()
{
double one = BetterRandom.NextDouble();
double two = BetterRandom.NextDouble();
return(Math.Sqrt(-2.0 * Math.Log(one)) * Math.Cos(6.2831853071795862 * two));
}
/// <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
}
private static IEnumerable <StatementSyntax> FindRandomExtractableCode(BaseMethodDeclarationSyntax extractFrom)
{
var statementsCount = extractFrom.Body.Statements.Count;
var startingPosition = BetterRandom.Between(0, statementsCount - 2);
var depth = BetterRandom.Between(1, statementsCount - startingPosition - 1);
var constraint = startingPosition + depth;
if (statementsCount < constraint)
{
throw new ArgumentOutOfRangeException($"startingPosition = {startingPosition}, depth = {depth}");
}
var returnNodes = new List <StatementSyntax>();
for (var i = startingPosition; i < constraint; i++)
{
var node = extractFrom.Body.Statements[i];
if (node != null)
{
returnNodes.Add(node);
}
}
return(returnNodes);
}
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);
}
void Awake()
{
betterRandom = new BetterRandom();
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
}
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 static List <double> RandomDoubles(int length)
{
Random r = BetterRandom.NewRandom();
var result = new List <double>(length);
double multiplier = Math.Pow(10.0, Math.Floor(Math.Log10(length) + 1.0));
for (int i = 0; i < length; i++)
{
result.Add(Math.Floor(r.NextDouble() * multiplier));
}
return(result);
}
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>();
}
public IHttpActionResult Post(OrderDTO orderDTO)
{
Order order = _mapper.Map <OrderDTO, Order>(orderDTO);
order.Status = Status.Started;
order.CreateDate = DateTime.Now;
BetterRandom random = new BetterRandom();
var toppings = _distributedPizzaDbContext.Toppings.ToList();
var orderManager = new OrderManager(toppings, random);
order.OrderReferenceId = GetNextSeqAPI();
//order.OrderReferenceId = Guid.NewGuid().ToString();
foreach (var pizza in order.Pizza)
{
int toppingsTogenerate = random.Next(1, 3);
for (var x = 0; x < toppingsTogenerate; x++)
{
int index = random.Next(toppings.Count);
var topping = toppings[index];
pizza.Toppings.Add(topping);
}
}
_distributedPizzaDbContext.Orders.Add(order);
_distributedPizzaDbContext.SaveChanges();
IStreamProcessingQueue queue;
switch (order.QueueType)
{
case QueueType.Kafka:
queue = new KafkaStreamProcessing();
break;
case QueueType.AmazonSQS:
queue = new AmazonSQSProcessingQueue();
break;
default:
queue = new KafkaStreamProcessing();
break;
}
queue.QueueOrder(order);
return(Ok(new OrderResponseDTO {
OrderReferenceId = order.OrderReferenceId
}));
}
public void GenerateRandomCustomer()
{
var random = new BetterRandom();
var customerManager = new CustomerManager(random);
List <Customer> customers = new List <Customer>();
for (var x = 0; x < 9; x++)
{
var customer = customerManager.GetRandomCustomer(random.Next(0, 6));
customers.Add(customer);
}
var count = customers.Count;
}
public void GenerateRandomOrder()
{
IKernel _Kernal = new StandardKernel();
_Kernal.Load(Assembly.GetExecutingAssembly());
IDistributedPizzaDbContext dbContext = _Kernal.Get <DistributedPizzaDbContext>();
var toppings = dbContext.Toppings.ToList();
BetterRandom random = new BetterRandom();
var orderManager = new OrderManager(toppings, random);
var order = orderManager.GenerateRandomOrder();
var order2 = orderManager.GenerateRandomOrder();
}
/// <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
}
}
}
public DNA(int size, Func <T> getRandomGene, Func <int, float> fitnessFunction, bool shouldInitGenes = true)
{
Genes = new T[size];
this.getRandomGene = getRandomGene;
this.fitnessFunction = fitnessFunction;
betterRandom = new BetterRandom();
if (shouldInitGenes)
{
for (int i = 0; i < Genes.Length; i++)
{
Genes[i] = getRandomGene();
}
}
}
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 static double RandomInDiscrete(List <double> probabilities)
{
double r = BetterRandom.NewRandom().NextDouble();
double sum = 0.0;
double result;
for (int i = 0; i < probabilities.Count; i++)
{
sum += probabilities[i];
if (sum >= r)
{
result = i;
return(result);
}
}
result = -1.0;
return(result);
}
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 CreateChild_Given2DifferentParents_ReturnsAChild()
{
var random = new BetterRandom(1);
var childFactory = new ChildFactory(new BiologyFactory(new Blender(random, 1, 2, 1), random));
var fathersBiology = new Biology(Sex.Male, 81.0m, 182.88m, new Color(42, 42, 9), new Color(42, 42, 0),
new Color(210, 210, 155), 180, 90, 80);
var father = new Person(null, null, fathersBiology);
var mothersBiology = new Biology(Sex.Female, 54m, 165m, new Color(230, 230, 90), new Color(5, 135, 60),
new Color(210, 185, 120), 130, 150, 130);
var mother = new Person(null, null, mothersBiology);
var child = childFactory.CreateChild(father, mother);
Assert.IsType <Person>(child);
Assert.NotNull(child);
}
public GeneticAlgorithm(int populationSize, int dnaSize, Func <T> getRandomGene, Func <int, float> fitnessFunction,
int elitism, float mutationRate = 0.01f)
{
Generation = 1;
Elitism = elitism;
MutationRate = mutationRate;
Population = new List <DNA <T> >(populationSize);
newPopulation = new List <DNA <T> >(populationSize);
this.dnaSize = dnaSize;
this.getRandomGene = getRandomGene;
this.fitnessFunction = fitnessFunction;
betterRandom = new BetterRandom();
BestGenes = new T[dnaSize];
for (int i = 0; i < populationSize; i++)
{
Population.Add(new DNA <T>(dnaSize, getRandomGene, fitnessFunction, shouldInitGenes: true));
}
}
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);
}
}
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;
}
}
}
/// <summary>
/// Randomizes the list, be arbitrarily reordering
/// sublists of stride elements. As the stride approaches
/// the size of the list, the options become very
/// limited.
/// </summary>
/// <remarks>
/// This could take a while for very large list
/// sizes.
/// </remarks>
public LSL_List llListRandomize(LSL_List src, int stride)
{
LSL_List result;
BetterRandom rand = new BetterRandom();
int chunkk;
int[] chunks;
m_host.AddScriptLPS(1);
if (stride <= 0)
{
stride = 1;
}
// Stride MUST be a factor of the list length
// If not, then return the src list. This also
// traps those cases where stride > length.
if (src.Length != stride && src.Length % stride == 0)
{
chunkk = src.Length/stride;
chunks = new int[chunkk];
for (int i = 0; i < chunkk; i++)
{
chunks[i] = i;
}
// Knuth shuffle the chunkk index
for (int i = chunkk - 1; i > 0; i--)
{
// Elect an unrandomized chunk to swap
int index = rand.Next(i + 1);
// and swap position with first unrandomized chunk
int tmp = chunks[i];
chunks[i] = chunks[index];
chunks[index] = tmp;
}
// Construct the randomized list
result = new LSL_List();
for (int i = 0; i < chunkk; i++)
{
for (int j = 0; j < stride; j++)
{
result.Add(src.Data[chunks[i] * stride + j]);
}
}
}
else {
object[] array = new object[src.Length];
Array.Copy(src.Data, 0, array, 0, src.Length);
result = new LSL_List(array);
}
return result;
}
public static int RandomInUniform(int a)
{
Random r = BetterRandom.NewRandom();
return((int)(r.NextDouble() * a));
}
