private bool AirSpawnLogic(int x, int z, ChunkSpawnableEntity entity, AbstractChunk chunk, ByteChunkCursor cursor, FastRandom rnd, out Vector3D entitySpawnLocation)
{
entitySpawnLocation = default(Vector3D);
int y;
int columnInfoIndex = x * AbstractChunk.ChunkSize.Z + z;
//Y base = Original world generated ground height (Before any player modification)
y = rnd.Next(chunk.BlockData.ColumnsInfo[columnInfoIndex].MaxHeight + 5, AbstractChunk.ChunkSize.Y);
if (y <= 0 || y >= AbstractChunk.ChunkSize.Y)
{
return(false);
}
cursor.SetInternalPosition(x, y, z);
if (cursor.Read() != WorldConfiguration.CubeId.Air)
{
return(false);
}
// Hurray it can spawn ! :D
//Add some randomnes on the cube where it will spawn
double XOffset, ZOffset;
XOffset = rnd.NextDouble(0.2, 0.8);
ZOffset = rnd.NextDouble(0.2, 0.8);
entitySpawnLocation = new Vector3D(chunk.BlockPosition.X + x + XOffset, cursor.InternalPosition.Y, chunk.BlockPosition.Z + z + ZOffset);
return(true);
}
/// <summary>
/// For activation functions that accept auxiliary arguments; generates random initial values for aux arguments for newly
/// added nodes (from an 'add neuron' mutation).
/// </summary>
public double[] GetRandomAuxArgs(FastRandom rng, double connectionWeightRange)
{
double[] auxArgs = new double[2];
auxArgs[0] = (rng.NextDouble() - 0.5) * 2.0;
auxArgs[1] = rng.NextDouble();
return(auxArgs);
}
private IEnumerable <char> GetRandomChar(int n, FastRandom rand)
{
for (int i = 0; i < n; i++)
{
double prob = rand.NextDouble();
double tabProb = 0.01 + 0.02 * rand.NextDouble(); //prob of tab is between 0.01 and 0.03
double newlineProb = 0.02 + 0.05 * rand.NextDouble(); //prob of newline is between 0.02 and 0.07
double spaceProb = 0.05 + 0.3 * rand.NextDouble(); //prob of space is between 0.05 and 0.35
double terminatorProb = 0.01 + 0.19 * rand.NextDouble(); //prob of sentence terminator is between 0.01 and 0.2
if (prob < tabProb)
{
yield return('\t');
}
if (prob < tabProb + newlineProb)
{
yield return('\n');
}
if (prob < tabProb + newlineProb + spaceProb)
{
yield return(' ');
}
if (prob < tabProb + newlineProb + spaceProb + terminatorProb)
{
yield return(terminators[rand.Next(0, terminators.Length)]);
}
else
{
yield return((char)rand.Next(33, 126 + 1));
}
}
}
private bool CaveSpawnLogic(int x, int z, ChunkSpawnableEntity entity, AbstractChunk chunk, ByteChunkCursor cursor, FastRandom rnd, out Vector3D entitySpawnLocation)
{
entitySpawnLocation = default(Vector3D);
int y;
int columnInfoIndex = x * AbstractChunk.ChunkSize.Z + z;
cursor.SetInternalPosition(x, 1, z);
//Move up until Air Block
while (cursor.Read() != WorldConfiguration.CubeId.Air)
{
//Move up, if top chunk height exit
if (cursor.Move(CursorRelativeMovement.Up) == false)
{
return(false);
}
}
int YFloorSpawning = cursor.InternalPosition.Y;
int MaximumSpawningHeight = chunk.BlockData.ColumnsInfo[columnInfoIndex].MaxGroundHeight - 10;
if (MaximumSpawningHeight <= 0)
{
MaximumSpawningHeight = 1;
}
//Move up until "solid" Block
while (cursor.Read() == WorldConfiguration.CubeId.Air && cursor.InternalPosition.Y <= MaximumSpawningHeight)
{
//Move up, if top chunk height exit
if (cursor.Move(CursorRelativeMovement.Up) == false)
{
return(false);
}
}
if (cursor.InternalPosition.Y > MaximumSpawningHeight)
{
return(false);
}
// Hurray it can spawn ! :D
//Add some randomnes on the cube where it will spawn
double XOffset, ZOffset;
XOffset = rnd.NextDouble(0.2, 0.8);
ZOffset = rnd.NextDouble(0.2, 0.8);
if (entity.SpawningPlace == ChunkSpawningPlace.FloorInsideCave)
{
entitySpawnLocation = new Vector3D(chunk.BlockPosition.X + x + XOffset, YFloorSpawning, chunk.BlockPosition.Z + z + ZOffset);
}
else
{
entitySpawnLocation = new Vector3D(chunk.BlockPosition.X + x + XOffset, cursor.InternalPosition.Y - 1, chunk.BlockPosition.Z + z + ZOffset);
}
return(true);
}
private double gaussianMutation(double mean, double stddev)
{
double x1 = 1 - _random.NextDouble();
double x2 = 1 - _random.NextDouble();
double y1 = Math.Sqrt(-2.0 * Math.Log(x1)) * Math.Cos(2.0 * Math.PI * x2);
return(y1 * stddev + mean);
}
private bool SurfaceSpawnLogic(int x, int z, ChunkSpawnableEntity entity, AbstractChunk chunk, ByteChunkCursor cursor, FastRandom rnd, out Vector3D entitySpawnLocation)
{
entitySpawnLocation = default(Vector3D);
int y;
int columnInfoIndex = x * AbstractChunk.ChunkSize.Z + z;
//Y base = Original world generated ground height (Before any player modification)
y = chunk.BlockData.ColumnsInfo[columnInfoIndex].MaxGroundHeight;
cursor.SetInternalPosition(x, y, z);
// verify that we can spawn here
var canSpawn = cursor.Read() != WorldConfiguration.CubeId.Air && cursor.Move(CursorRelativeMovement.Up) &&
cursor.Read() == WorldConfiguration.CubeId.Air && cursor.Move(CursorRelativeMovement.Up) &&
cursor.Read() == WorldConfiguration.CubeId.Air;
// return cursor to the spawn point
cursor.Move(CursorRelativeMovement.Down);
if (!canSpawn)
{
return(false);
}
// Check that the block is well "Solid to entity"
BlockProfile blockSpawnProfile = _config.BlockProfiles[cursor.Peek(CursorRelativeMovement.Down)];
if (!blockSpawnProfile.IsSolidToEntity)
{
return(false);
}
if (entity.IsWildChunkNeeded)
{
//Get Chunk master biome
byte masterBiomeId = chunk.BlockData.ChunkMetaData.ChunkMasterBiomeType;
//Get biome surface block layer
byte surfaceBiomeCube = _config.ProcessorParam.Biomes[masterBiomeId].SurfaceCube;
//If the entity need a Wild chunk, then it can only spawn on a cube surface equal to the default biome surface cube !
if (surfaceBiomeCube != blockSpawnProfile.Id)
{
return(false);
}
}
// Hurray it can spawn ! :D
//Add some randomnes on the cube where it will spawn
double XOffset, ZOffset;
XOffset = rnd.NextDouble(0.2, 0.8);
ZOffset = rnd.NextDouble(0.2, 0.8);
entitySpawnLocation = new Vector3D(chunk.BlockPosition.X + x + XOffset, cursor.InternalPosition.Y, chunk.BlockPosition.Z + z + ZOffset);
return(true);
}
private void PopulateChunkWithCave(ByteChunkCursor cursor, int x, int y, int z, int layers, byte cubeId, FastRandom rnd)
{
cursor.SetInternalPosition(x, y, z);
int caveRadius = rnd.Next(3, 8);
int layerRadiusModifier = 0;
for (int l = 0; l < layers; l++)
{
//Generate Lake Layers
for (int X = x - (caveRadius - layerRadiusModifier); X <= x + (caveRadius - layerRadiusModifier); X++)
{
for (int Z = z - (caveRadius - layerRadiusModifier); Z <= z + (caveRadius - layerRadiusModifier); Z++)
{
//Create "Noise" at Cave border
if ((X == x - (caveRadius - layerRadiusModifier) ||
X == x + (caveRadius - layerRadiusModifier) ||
Z == z - (caveRadius - layerRadiusModifier) ||
Z == z + (caveRadius - layerRadiusModifier)) &&
rnd.NextDouble() < 0.2)
{
continue;
}
cursor.SetInternalPosition(X, y + l, Z);
if (l <= 1 && rnd.NextDouble() < 0.3)
{
cursor.Write(cubeId);
}
else
{
if (l != 0)
{
if (l == layers - 1)
{
if (cursor.Read() == UtopiaProcessorParams.CubeId.Stone)
{
cursor.Write(UtopiaProcessorParams.CubeId.LightWhite);
}
}
else
{
cursor.Write(UtopiaProcessorParams.CubeId.Air);
}
}
}
}
}
if (layerRadiusModifier < caveRadius)
{
layerRadiusModifier++;
}
}
}
/// <summary>
/// Initialise agent and prey positions. The prey is positioned randomly with at least 4 empty squares between it and a wall (in all directions).
/// The agent is positioned randomly but such that the prey is within sensor range (distance 2 or less).
/// </summary>
public void InitPositions()
{
// Random pos at least 4 units away from any wall.
_preyPos._x = 4 + _rng.Next(_gridSize - 8);
_preyPos._y = 4 + _rng.Next(_gridSize - 8);
// Agent position. Within range of the prey.
double t = 2.0 * Math.PI * _rng.NextDouble(); // Random angle.
double r = 2.0 + _rng.NextDouble() * 2.0; // Distance between 2 and 4.
_agentPos._x = _preyPos._x + (int)Math.Floor(Math.Cos(t) * r);
_agentPos._y = _preyPos._y + (int)Math.Floor(Math.Sin(t) * r);
}
private void initialize(double delta) // randomly initialize the weights for this individual, with a maximum perterbance of delta
{
for (int i = 0; i < weights.Length; i++)
{
for (int j = 0; j < weights[i].Length; j++)
{
for (int k = 0; k < weights[i][j].Length; k++)
{
weights[i][j][k] = (float)(r.NextDouble() * delta * 2 - delta);
}
}
}
}
public static void Initialize(uint seed)
{
_generator = new GlobalGenerator(seed);
_treePositions = new List <Vector3Int>();
var rand = new FastRandom(seed);
for (var i = 0; i < 5000; i++)
{
var sample = new Vector2Int((int)((rand.NextDouble() * 100 - 50) * 32),
(int)((rand.NextDouble() * 100 - 50) * 32));
var height = _generator.GetHeight(sample.x, sample.y);
_treePositions.Add(new Vector3Int(sample.x, height, sample.y));
}
}
private char GetRandomChar(FastRandom rand)
{
if (rand.NextDouble() < 0.15)
{
return(' ');
}
if (rand.NextDouble() < 0.2)
{
return('\n');
}
int value = rand.Next(0, 94 + 1);
return((char)(value + 32));
}
internal int GetRandomValue(float noteNeed2, float noteNeed3, float noteNeed4 = 1, float noteNeed5 = 1, float noteNeed6 = 1)
{
double val = random.NextDouble();
if (val >= noteNeed6)
{
return(6);
}
else if (val >= noteNeed5)
{
return(5);
}
else if (val >= noteNeed4)
{
return(4);
}
else if (val >= noteNeed3)
{
return(3);
}
else if (val >= noteNeed2)
{
return(2);
}
else
{
return(1);
}
}
public UnitLock SelectOptimalLockTargetFor(ActiveModule module)
{
var locks = GetLocks().OfType <UnitLock>().Where(l =>
{
if (l.State != LockState.Locked)
{
return(false);
}
var isInOptimalRange = IsInRangeOf3D(l.Target, module.OptimalRange);
return(isInOptimalRange);
}).ToArray();
var primaryLock = locks.FirstOrDefault(l => l.Primary);
if (module.ED.AttributeFlags.PrimaryLockedTarget)
{
return(primaryLock);
}
var chance = FastRandom.NextDouble() <= PRIMARY_LOCK_CHANCE_FOR_SECONDARY_MODULE;
if (primaryLock != null && chance)
{
return(primaryLock);
}
return(locks.RandomElement());
}
protected virtual void BatchDraw(Microsoft.Xna.Framework.Graphics.SpriteBatch batch)
{
rnd.Reinitialise(seed);
r1 = (float)rnd.NextDouble();
r2 = (float)rnd.NextDouble();
r3 = (float)rnd.NextDouble();
for (int i = 0; i < particleCount; i++)
{
r0 = (float)rnd.NextDouble();
ParticleDraw(i, batch);
r3 = r2;
r2 = r1;
r1 = r0;
}
}
private int CalculateEp()
{
var activeGathererModules = ParentRobot.ActiveModules.OfType <GathererModule>().Where(m => m.State.Type != ModuleStateType.Idle).ToArray();
if (activeGathererModules.Length == 0)
{
return(0);
}
var avgCycleTime = activeGathererModules.Select(m => m.CycleTime).Average();
var t = TimeSpan.FromDays(1).Divide(avgCycleTime);
var chance = (double)MAX_EP_PER_DAY / t;
chance /= activeGathererModules.Length;
var rand = FastRandom.NextDouble();
if (rand <= chance)
{
return(1);
}
return(0);
}
public void Visit(Player player)
{
if (_npc.Behavior.Type != NpcBehaviorType.Aggressive)
{
return;
}
if (player.HasTeleportSicknessEffect)
{
return;
}
if (!_npc.ThreatManager.Hostiles.IsEmpty)
{
return;
}
if (!_npc.IsInAggroRange(player))
{
return;
}
var threat = Threat.BODY_PULL + FastRandom.NextDouble(0, 5);
_npc.AddThreat(player, new Threat(ThreatType.Bodypull, threat));
}
protected virtual bool CheckAccuracy(Unit victim)
{
var rnd = FastRandom.NextDouble();
var isMiss = rnd * _accuracy.Value > victim.SignatureRadius;
return(isMiss);
}
/// <summary>
/// A random item will be pickes using its chanse.
/// </summary>
public T GetRandomItem()
{
if (TotalProbability == 0.0d)
{
throw new ArgumentNullException(typeof(ProbabilityList <T>).ToString(), "There is no item in list");
}
if (TotalProbability < 1.0d)
{
T lastItem = items.Last().Key;
items[lastItem] += (1.0d - TotalProbability);
TotalProbability = 1.0d;
}
double randomPercent = random.NextDouble();
double currentItemProbabilityMaxValue = 0.0d;
foreach (var item in items)
{
currentItemProbabilityMaxValue += item.Value;
if (currentItemProbabilityMaxValue > 1.0d)
{
currentItemProbabilityMaxValue = 1.0d;
}
if (randomPercent <= currentItemProbabilityMaxValue)
{
return(item.Key);
}
}
throw new ArgumentException("Reassign " + nameof(ProbabilityList <T>));
}
public void Visit(AreaBomb bomb)
{
if (!_npc.IsInAggroRange(bomb))
{
return;
}
// csak akkor ha van is mivel tamadni
if (!_npc.ActiveModules.Any(m => m is WeaponModule))
{
return;
}
// ha valaki mar foglalkozik a bombaval akkor ne csinaljon semmit
var g = _npc._group;
if (g != null && g.Members.Any(m => m.ThreatManager.Contains(bomb)))
{
return;
}
var threat = Threat.BODY_PULL;
if (!_npc.ThreatManager.Hostiles.IsEmpty)
{
var h = _npc.ThreatManager.GetMostHatedHostile();
if (h != null)
{
threat = h.Threat * 100;
}
}
_npc.AddThreat(bomb, new Threat(ThreatType.Bodypull, threat + FastRandom.NextDouble(0, 5)));
}
protected override bool CheckAccuracy(Unit victim)
{
var rnd = FastRandom.NextDouble();
var isMiss = rnd > ParentRobot.MissileHitChance;
return(isMiss);
}
private PlantRule GetNewPlantRule(int globalX, int globalY)
{
var area = Area.FromRadius(globalX, globalY, _neighbourRadius);
var excludedTypes = GetPlayerSeededTypes;
var neighbouringPlants = GetPlantTypeCountFromRange(area, excludedTypes);
PlantType resultPlantType;
if (neighbouringPlants.Count == 0)
{
//no plants, then fertility decides
resultPlantType = GetAllPlantRules.GetWinnerPlantTypeBasedOnFertility();
}
else
{
var rulingPlant = neighbouringPlants.OrderBy(k => k.Value).Last().Key;
var plantTypeBySpreading = GetAllPlantRules.GetSpreadingBasedWinnerPlantType(neighbouringPlants);
//50% currently ruling plant OR spreading types
resultPlantType = FastRandom.NextDouble() < 0.5 ? rulingPlant : plantTypeBySpreading;
}
return(GetAllPlantRules.FirstOrDefault(p => p.Type == resultPlantType));
}
public static void ApplyPositionOffsets(IBeatmap beatmap, params Mod[] mods)
{
var rng = new FastRandom(RNG_SEED);
bool shouldApplyHardRockOffset = mods.Any(m => m is ModHardRock);
float? lastPosition = null;
double lastStartTime = 0;
foreach (var obj in beatmap.HitObjects.OfType <CatchHitObject>())
{
obj.XOffset = 0;
switch (obj)
{
case Fruit fruit:
if (shouldApplyHardRockOffset)
{
applyHardRockOffset(fruit, ref lastPosition, ref lastStartTime, rng);
}
break;
case BananaShower bananaShower:
foreach (var banana in bananaShower.NestedHitObjects.OfType <Banana>())
{
banana.XOffset = (float)(rng.NextDouble() * CatchPlayfield.WIDTH);
rng.Next(); // osu!stable retrieved a random banana type
rng.Next(); // osu!stable retrieved a random banana rotation
rng.Next(); // osu!stable retrieved a random banana colour
}
break;
case JuiceStream juiceStream:
// Todo: BUG!! Stable used the last control point as the final position of the path, but it should use the computed path instead.
lastPosition = juiceStream.X + juiceStream.Path.ControlPoints[^ 1].Position.Value.X;
private ArtifactType GetNextArtifactType()
{
if (!HasArtifacts())
{
return(ArtifactType.undefined);
}
var spawnRates = _artifactSpawnRates[_zone.Id].ToArray();
var sumRate = spawnRates.Sum(r => r.rate);
var minRate = 0.0;
var chance = FastRandom.NextDouble();
foreach (var spawnRate in spawnRates)
{
var rate = spawnRate.rate / sumRate;
var maxRate = rate + minRate;
if (minRate < chance && chance <= maxRate)
{
return(spawnRate.artifactType);
}
minRate += rate;
}
return(ArtifactType.undefined);
}
/// <summary>
/// Function that will try to get a place where the entity can spawn, it will apply spawning restrictions.
/// </summary>
/// <param name="entity">The entity</param>
/// <param name="chunk">The chunk where the entity must be placed</param>
/// <param name="cursor">A cursor on the chunk block data</param>
/// <param name="rnd">Randomnes generator</param>
/// <param name="entitySpawnLocation">Returned spawn location, will be [0;0;0] if entity cannot be placed</param>
/// <returns>False if the entity cannot be placed</returns>
public bool TryGetSpawnLocation(ChunkSpawnableEntity entity, AbstractChunk chunk, ByteChunkCursor cursor, FastRandom rnd, out Vector3D entitySpawnLocation)
{
entitySpawnLocation = default(Vector3D);
//Test spawning chance
if (rnd.NextDouble() <= entity.SpawningChance)
{
return(false);
}
//Get Rnd chunk Location X/Z
int x = rnd.Next(0, 16);
int z = rnd.Next(0, 16);
//Column Info index
int columnInfoIndex = x * AbstractChunk.ChunkSize.Z + z;
int y;
switch (entity.SpawningPlace)
{
case ChunkSpawningPlace.FloorInsideCave:
case ChunkSpawningPlace.CeilingInsideCave:
return(CaveSpawnLogic(x, z, entity, chunk, cursor, rnd, out entitySpawnLocation));
case ChunkSpawningPlace.AirAboveSurface:
return(AirSpawnLogic(x, z, entity, chunk, cursor, rnd, out entitySpawnLocation));
case ChunkSpawningPlace.Surface:
default:
return(SurfaceSpawnLogic(x, z, entity, chunk, cursor, rnd, out entitySpawnLocation));
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static string GetRandomChar()
{
var _loc2 = Math.Ceiling(Random.NextDouble() * 100);
if (_loc2 <= 40)
{
return(((char)Math.Floor(Random.NextDouble() * 26) + 65).ToString());
}
else if (_loc2 <= 80)
{
return(((char)Math.Floor(Random.NextDouble() * 26) + 97).ToString());
}
else
{
return(((char)Math.Floor(Random.NextDouble() * 10) + 48).ToString());
}
}
public RandomPolynomial(int degree, double maxCoefficientMagnitude, FastRandom r)
{
Coefficients = new double[degree + 1];
for (var i = 0; i <= degree; i++)
{
Coefficients[i] = (r.NextDouble() - 0.5) * maxCoefficientMagnitude * 2; // Permit range [-maxCoefficientMagnitude, +maxCoefficientMagnitude)
}
}
private double RandomizeDirection(double direction)
{
var randomModifier = (FastRandom.NextDouble(-(1 - _module.ScanAccuracy), (1 - _module.ScanAccuracy))) * RANDOM_INTERVAL;
direction += randomModifier;
MathHelper.NormalizeDirection(ref direction);
return(direction);
}
public IntervalTimer(TimeSpan interval, bool random = false)
{
Interval = interval;
if (random)
{
Elapsed = TimeSpan.FromMilliseconds(FastRandom.NextDouble() * interval.TotalMilliseconds);
}
}
public void ReplaceIndicesByRandomValue(IDictionary <int, IList <int> > cells, bool considerSelection = false)
{
var rand = new FastRandom();
ReplaceIndicesByValues(cells,
col => {
double min = PreprocessingData.GetMin <double>(col, considerSelection);
double max = PreprocessingData.GetMax <double>(col, considerSelection);
double range = max - min;
return(cells[col].Select(_ => rand.NextDouble() * range + min));
},
col => {
var min = PreprocessingData.GetMin <DateTime>(col, considerSelection);
var max = PreprocessingData.GetMax <DateTime>(col, considerSelection);
double range = (max - min).TotalSeconds;
return(cells[col].Select(_ => min + TimeSpan.FromSeconds(rand.NextDouble() * range)));
});
}
public static IEnumerable <long> GenerateUniformDistributedValues(int n, long start, long end, FastRandom rand)
{
for (int i = 0; i < n; i++)
{
double r = rand.NextDouble(); // r \in [0, 1)
r = r * ((end + 1) - start) + start; // r \in [start, end + 1), the "+ 1" makes sure that it is uniformlly distibuted when using floor in the next line
yield return((long)Math.Floor(r));
}
}
private static void TestExpressions()
{
/* Wood
double s = pow ( SineWave ( RingSpacing*sqrt ( x*x+y*y ) + TurbScale * Turbulence ( p, 3 ) ), Squeeze );
t.Color = ( 1 - s ) * LightWood + s * DarkWood;
string wood = "unit-$pow<$saw<3*sqrt<x*x+y*y*>+1.8*$t<c,3>>,5>";
*/
string wood = "(unit-($saw<3*$sqrt<x*x+y*y*>>+$t<c,3>))*lw + ( ($saw<3*$sqrt<x*x+y*y*>>+$t<c,3>)*dw)";
string expression = wood;
//@"unit*$sqrt<x*x+y*y>";
float x = 0.5f;
float y = 0.7f;
var p = new Vector(x, y, 2 - x - y);
var p0 = new Vector(x, y, 0);
var u = new RgbSpectrum(1f);
var rnd = new FastRandom();
var c = new RgbSpectrum(NoiseProvider.Instance.Noise3D(p));
var evaluator = new GenericExpressionEvaluator<RgbSpectrum>((i) =>
{
if (i is float)
{
return new RgbSpectrum((float)i);
}
if (i is double)
{
return new RgbSpectrum((float)((double)i));
}
if (i is int)
{
return new RgbSpectrum((int)i);
}
if (i is Int64)
{
return new RgbSpectrum((int)i);
}
return (RgbSpectrum)i;
}, RgbSpectrum.FromStringData);
var func = evaluator.Compile(expression);
var f = rnd.NextDouble();
Console.WriteLine("Script version: {0}", func(new
{
e = f,
c,
u,
unit = RgbSpectrum.UnitSpectrum(),
lw = new RgbSpectrum(0.5f, 0.2f, 0.3f),
dw = new RgbSpectrum(0.3f, 0.1f, 0.1f),
x,
y,
arr = new[] { 0.5, 0.6, 0.6 },
n = c * 0.5f,
}));
Console.WriteLine("C# version : {0}", c * Math.Sqrt(x * x + y * y));
return;
}
/// <summary>
/// For activation functions that accept auxiliary arguments; generates random initial values for aux arguments for newly
/// added nodes (from an 'add neuron' mutation).
/// </summary>
public double[] GetRandomAuxArgs(FastRandom rng, double connectionWeightRange)
{
double[] auxArgs = new double[2];
auxArgs[0] = (rng.NextDouble()-0.5) * 2.0;
auxArgs[1] = rng.NextDouble();
return auxArgs;
}
public override void SetSpawnPosition (Vector3 playerSpawn, PhysicsComponent ownPhysics, object map, FastRandom rand)
{
Maze.Maze maze = map as Maze.Maze;
if (maze != null)
{
bool gotit = false;
while (!gotit)
{
int pos = rand.Next (0, maze.graph.Nodes.Count);
Vector3 spawn_pos;
float distance;
for (int i = pos; i < maze.graph.Nodes.Count; i++)
{
spawn_pos = maze.graph.Nodes[i].Data.WorldPosition;
Vector3.Distance(ref playerSpawn, ref spawn_pos, out distance);
if (maze.graph.Nodes[i].Data.MazeCellType == MazeCellType.Ground && distance > 50 &&
!maze.graph.Nodes[i].Data.IsExit)
{
gotit = true;
ownPhysics.RigidBody.Position = new JVector (maze.graph.Nodes[i].Data.WorldPosition.X, height,
maze.graph.Nodes[i].Data.WorldPosition.Z);
break;
}
}
}
if (!gotit)
{
Logger.Log.AddLogEntry (LogLevel.Severe, "GhostAI", "Failed to generate spawn position!");
}
fallback = JVector.Transform (JVector.Backward, JMatrix.CreateFromAxisAngle (JVector.Up,
(float) rand.NextDouble() * 2 * MathHelper.Pi));
direction = fallback;
Spawned = true;
}
}
public Particle(FastRandom rnd)
{
Deviation0 = (float)rnd.NextDouble() * 2f - 1f;
//Deviation1 = (float)rnd.NextDouble() * 2f - 1f;
//TextureIndex = (ushort)rnd.Next(4);
}