private MobSpawner <ZombieFactory> CreateMobSpawner(ILogger logger,
UnityTimeProvider timeProvider,
EntitiesSpawner entitiesSpawner,
TypeTargetLocator tankMobTargetLocator,
StateMachineFactory stateMachineFactory,
DefaultRandom random)
{
var zombieFactories = new List <ZombieFactory>();
foreach (var zombiePrefab in Zombies)
{
var pool = new SimplePool <Zombie>(logger,
15,
10,
p =>
{
var zombie = Instantiate(zombiePrefab);
return(zombie);
});
var zombieFactory = new ZombieFactory(timeProvider, entitiesSpawner, tankMobTargetLocator, stateMachineFactory, _deps.Doors, pool);
zombieFactories.Add(zombieFactory);
}
var zombieSpawnPoints = GetZombieSpawnPoints(_deps.ZombieSpawnPoints);
var mobSpawner = new MobSpawner <ZombieFactory>(random, entitiesSpawner, new MobSpawnerSettings(AliveZombieCount, zombieSpawnPoints), zombieFactories);
return(mobSpawner);
}
private static Point PopRandom(List <Point> Points, DefaultRandom Generator)
{
int Idx = Generator.RandomInt(Points.Count - 1);
Point P = Points[Idx];
Points.RemoveAt(Idx);
return(P);
}
/// <summary>
/// Construct a new instance of the Simulation class
/// </summary>
/// <param name="startDate">The starting date of the simulation</param>
/// <param name="iterationNo">The iteration of this simulation</param>
/// <param name="seed">the seed value for the random generator</param>
/// <param name="shuffleTransitions">Sets whether the order in which state transitions are tested is shuffled randomly</param>
protected Simulation(DateTime startDate, int iterationNo, int seed, bool shuffleTransitions)
{
IterationNo = iterationNo;
StartDate = startDate;
RandomProvider = new DefaultRandom(seed);
_shuffleTransitions = shuffleTransitions;
RootContext = new Region <TAgent>("root", "root", "Global"); // This is fine because it is only a grouped context - not an instance of TG
_allContexts.Add(RootContext.Name, RootContext);
}
public void RandomMinMaxValueTest()
{
var random = new DefaultRandom();
for (var i = 0; i < 1000; i++)
{
var next = random.Next(10, 20);
Assert.InRange(next, 10, 20);
}
}
public void BasicLoremIpsumGeneratorTest()
{
var random = new DefaultRandom(12345);
var gen = new LoremIpsumGenerator(random);
var text = gen.CreateText(1);
Assert.Equal("lorem", text);
text = gen.CreateText(10);
Assert.Equal("lorem ipsum dolor sit amet stet kasd gubergren tempor dolor", text);
}
public void BasicRandomTest()
{
var random = new DefaultRandom(12345);
var next = random.Next();
Assert.Equal(143337951, next);
next = random.Next();
Assert.Equal(150666398, next);
next = random.Next();
Assert.Equal(1663795458, next);
}
public void TestRandomPointWithin()
{
DefaultRandom random = new DefaultRandom();
AxisAlignedRectangle2 testRectangle = new AxisAlignedRectangle2(
new Vector2(12.3f, 45.6f), new Vector2(98.7f, 65.4f)
);
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector2 randomPoint = testRectangle.RandomPointWithin(random);
Assert.AreEqual(testRectangle.ClosestPointTo(randomPoint), randomPoint);
}
}
public void RandomMinMaxValueTest2()
{
var random = new DefaultRandom();
var hitCount = new int[4];
for (var i = 0; i < 1000; i++)
{
var next = random.Next(0, 3);
hitCount[next]++;
}
Assert.True(hitCount[0] > 0);
Assert.True(hitCount[3] > 0);
}
public void TestRandomPointOnPerimeterForYPlane()
{
IRandom randomNumberGenerator = new DefaultRandom();
Plane3 yPlane = new Plane3(Vector3.UnitY * 2.0f, Vector3.Up);
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector3 randomPoint = yPlane.RandomPointOnPerimeter(randomNumberGenerator);
Assert.IsTrue(float.IsInfinity(randomPoint.X));
Assert.AreEqual(2.0f, randomPoint.Y);
Assert.IsTrue(float.IsInfinity(randomPoint.Z));
}
}
public void TestRandomPointWithinForZPlane()
{
IRandom randomNumberGenerator = new DefaultRandom();
Plane3 zPlane = new Plane3(Vector3.UnitZ * 2.0f, Vector3.Backward);
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector3 randomPoint = zPlane.RandomPointWithin(randomNumberGenerator);
Assert.IsTrue(float.IsInfinity(randomPoint.X));
Assert.IsTrue(float.IsInfinity(randomPoint.Y));
Assert.AreEqual(2.0f, randomPoint.Z);
}
}
public void TestWeightedSampling()
{
var choices = new List <WeightedChoice <string> >
{
new WeightedChoice <string>("A", 0.25),
new WeightedChoice <string>("B", 0.25),
new WeightedChoice <string>("C", 0.25),
new WeightedChoice <string>("D", 0.25)
};
var random = new DefaultRandom(1234);
var result = WeightedSampler <string> .PickMultipleItems(choices, 2, random);
Assert.AreEqual(2, result.Count);
}
public void BasicLoremIpsumGeneratorToFileTest()
{
var random = new DefaultRandom(12345);
var gen = new LoremIpsumGenerator(random);
var tmp = new DefaultTempUtil();
tmp.UseFile(tempFile =>
{
using (var writer = new StreamWriter(tempFile))
gen.WriteText(10, writer);
var fileContents = File.ReadAllText(tempFile);
Assert.Equal("lorem ipsum dolor sit amet stet kasd gubergren tempor ipsum", fileContents);
});
}
public void TestRandomPointOnPerimeter()
{
Disc2 testDisc = new Disc2(new Vector2(123.4f, 567.8f), 9.0f);
DefaultRandom randomNumberGenerator = new DefaultRandom();
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector2 randomPoint = testDisc.RandomPointOnPerimeter(randomNumberGenerator);
Assert.That(
(testDisc.Center - randomPoint).Length(),
Is.EqualTo(testDisc.Radius).Within(36).Ulps
// TODO: This method suffers from accuracy problems!
);
}
}
public void TestReservoir()
{
var choices = new List <string>
{
"A", "B", "C", "D", "E"
};
var weights = new List <double>
{
0.3, 0.25, 0.2, 0.15, 0.1
};
var random = new DefaultRandom(1234);
var selected = Reservoir.ReservoirSampling(weights, 2, random);
Assert.AreEqual(2, selected.Count());
}
public void TestRandomPointWithin()
{
Disc2 testDisc = new Disc2(new Vector2(123.4f, 567.8f), 9.0f);
DefaultRandom randomNumberGenerator = new DefaultRandom();
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector2 randomPoint = testDisc.RandomPointWithin(randomNumberGenerator);
float randomPointDistance = (testDisc.Center - randomPoint).Length();
if (!FloatHelper.AreAlmostEqual(randomPointDistance, testDisc.Radius, 36))
{
Assert.LessOrEqual(randomPointDistance, testDisc.Radius);
}
}
}
private static Point GenerateRandomPointAround(Point P, float MinDist, DefaultRandom Generator)
{
// start with non-uniform distribution
float R1 = Generator.RandomFloat();
float R2 = Generator.RandomFloat();
// radius should be between MinDist and 2 * MinDist
float Radius = MinDist * (R1 + 1.0f);
// random angle
float Angle = 2 * 3.141592653589f * R2;
// the new point is generated around the point (x, y)
float X = (float)(P.x + Radius * Math.Cos(Angle));
float Y = (float)(P.y + Radius * Math.Sin(Angle));
return(new Point(X, Y));
}
public void TestRandomPointOnPerimeter()
{
DefaultRandom random = new DefaultRandom();
AxisAlignedRectangle2 testRectangle = new AxisAlignedRectangle2(
new Vector2(12.3f, 45.6f), new Vector2(98.7f, 65.4f)
);
float[] possibleXs = new float[] { 12.3f, 98.7f };
float[] possibleYs = new float[] { 45.6f, 65.4f };
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector2 randomPoint = testRectangle.RandomPointOnPerimeter(random);
Assert.AreEqual(testRectangle.ClosestPointTo(randomPoint), randomPoint);
Assert.IsTrue(
arrayContains(possibleXs, randomPoint.X) || arrayContains(possibleYs, randomPoint.Y)
);
}
}
public void Extend(ITestController testController, object suite)
{
var suiteType = suite.GetType();
var fieldsWithAttribute = suiteType.GetFieldsWithAttribute <AutoDataAttribute>()
.OrderBy(x => x.Item1.Name).ToList();
if (fieldsWithAttribute.Count == 0)
{
return;
}
var seed = GetSeed(suiteType);
var random = new DefaultRandom(seed);
var configuration = GetAutoDataConfiguration(suiteType);
var generator = TestDataGeneratorFactory.Create(x => configuration(x).UseRandom(random));
// TODO: add seed to data
testController.AddAction <SetupExtension>(
$"<Create_AutoData><{seed}>",
x => fieldsWithAttribute.ForEach(t => CreateAndAssignAuto(suite, generator, t.Item2, t.Item1)));
}
public void TestRandomPointOnSurface()
{
Sphere3 unitSphere = new Sphere3(Vector3.Zero, 1.0f);
Sphere3 innerSphere = new Sphere3(Vector3.Zero, 1.0f - Specifications.HullAccuracy);
Sphere3 outerSphere = new Sphere3(Vector3.Zero, 1.0f + Specifications.HullAccuracy);
DefaultRandom random = new DefaultRandom();
Vector3 total = Vector3.Zero;
for (int i = 0; i < Specifications.ProbabilisticFunctionSamples; ++i)
{
Vector3 point = unitSphere.RandomPointOnSurface(random);
Assert.IsFalse(
innerSphere.Contains(point), "Random point lies on the sphere's hull"
);
Assert.IsTrue(
outerSphere.Contains(point), "Random point lies on the sphere's hull"
);
total += point;
}
total /= Specifications.ProbabilisticFunctionSamples;
Assert.AreEqual(
0.0f, total.X, Specifications.ProbabilisticFunctionDeviation,
"Random points average on the center of the sphere on the X axis"
);
Assert.AreEqual(
0.0f, total.Y, Specifications.ProbabilisticFunctionDeviation,
"Random points average on the center of the sphere on the Y axis"
);
Assert.AreEqual(
0.0f, total.Z, Specifications.ProbabilisticFunctionDeviation,
"Random points average on the center of the sphere on the Z axis"
);
}
public override void Init(List <SceneNode> sceneNodes)
{
var logger = CreateLogger();
_deps = GetDeps(sceneNodes);
var random = new DefaultRandom(new Random());
var tankMobTargetLocator = new TypeTargetLocator(EntityType.Tank);
var targetLocators = new List <ITargetLocator>
{
tankMobTargetLocator
};
var entitiesSpawner = new EntitiesSpawner(targetLocators);
var timeProvider = new UnityTimeProvider();
CreateTank(logger, timeProvider, entitiesSpawner);
var stateMachineFactory = new StateMachineFactory();
var mobSpawner = CreateMobSpawner(logger, timeProvider, entitiesSpawner, tankMobTargetLocator, stateMachineFactory, random);
mobSpawner.Start();
}
public void TestRandomPointOnPerimeter()
{
IRandom randomNumberGenerator = new DefaultRandom();
// A random point has to involve infinity (since the chance that of hitting the
// meager numeric range of a float, or any other finite number system, is about
// zero for a infinitely large plane). But given the orientation of the plane,
// only these combinations of positive and negative infinity can be possible.
Vector3[] possiblePoints = new Vector3[] {
new Vector3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity),
new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.PositiveInfinity),
new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.NegativeInfinity),
new Vector3(float.PositiveInfinity, float.NegativeInfinity, float.NegativeInfinity),
};
Plane3 plane = new Plane3(Vector3.Zero, Vector3.Normalize(Vector3.One));
for (int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index)
{
Vector3 randomPoint = plane.RandomPointOnPerimeter(randomNumberGenerator);
CollectionAssert.Contains(possiblePoints, randomPoint);
}
}
public void TestRandomPointOnPerimeter() {
DefaultRandom random = new DefaultRandom();
AxisAlignedRectangle2 testRectangle = new AxisAlignedRectangle2(
new Vector2(12.3f, 45.6f), new Vector2(98.7f, 65.4f)
);
float[] possibleXs = new float[] { 12.3f, 98.7f };
float[] possibleYs = new float[] { 45.6f, 65.4f };
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector2 randomPoint = testRectangle.RandomPointOnPerimeter(random);
Assert.AreEqual(testRectangle.ClosestPointTo(randomPoint), randomPoint);
Assert.IsTrue(
arrayContains(possibleXs, randomPoint.X) || arrayContains(possibleYs, randomPoint.Y)
);
}
}
public void TestRandomPointOnPerimeterForYPlane() {
IRandom randomNumberGenerator = new DefaultRandom();
Plane3 yPlane = new Plane3(Vector3.UnitY * 2.0f, Vector3.Up);
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector3 randomPoint = yPlane.RandomPointOnPerimeter(randomNumberGenerator);
Assert.IsTrue(float.IsInfinity(randomPoint.X));
Assert.AreEqual(2.0f, randomPoint.Y);
Assert.IsTrue(float.IsInfinity(randomPoint.Z));
}
}
public void TestRandomPointWithinForZPlane() {
IRandom randomNumberGenerator = new DefaultRandom();
Plane3 zPlane = new Plane3(Vector3.UnitZ * 2.0f, Vector3.Backward);
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector3 randomPoint = zPlane.RandomPointWithin(randomNumberGenerator);
Assert.IsTrue(float.IsInfinity(randomPoint.X));
Assert.IsTrue(float.IsInfinity(randomPoint.Y));
Assert.AreEqual(2.0f, randomPoint.Z);
}
}
public void TestRandomPointWithin() {
IRandom randomNumberGenerator = new DefaultRandom();
// A random point has to involve infinity (since the chance that of hitting the
// meager numeric range of a float, or any other finite number system, is about
// zero for a infinitely large plane). But given the orientation of the plane,
// only these combinations of positive and negative infinity can be possible.
Vector3[] possiblePoints = new Vector3[] {
new Vector3(float.NegativeInfinity, float.PositiveInfinity, float.PositiveInfinity),
new Vector3(float.NegativeInfinity, float.NegativeInfinity, float.PositiveInfinity),
new Vector3(float.PositiveInfinity, float.PositiveInfinity, float.NegativeInfinity),
new Vector3(float.PositiveInfinity, float.NegativeInfinity, float.NegativeInfinity),
};
Plane3 plane = new Plane3(Vector3.Zero, Vector3.Normalize(Vector3.One));
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector3 randomPoint = plane.RandomPointWithin(randomNumberGenerator);
//Assert.That(randomPoint, Is.OneOf(possiblePoints));
CollectionAssert.Contains(possiblePoints, randomPoint);
}
}
public void TestRandomPointWithin() {
Disc2 testDisc = new Disc2(new Vector2(123.4f, 567.8f), 9.0f);
DefaultRandom randomNumberGenerator = new DefaultRandom();
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector2 randomPoint = testDisc.RandomPointWithin(randomNumberGenerator);
float randomPointDistance = (testDisc.Center - randomPoint).Length();
if(!FloatHelper.AreAlmostEqual(randomPointDistance, testDisc.Radius, 36)) {
Assert.LessOrEqual(randomPointDistance, testDisc.Radius);
}
}
}
public void TestRandomPointOnPerimeter() {
Disc2 testDisc = new Disc2(new Vector2(123.4f, 567.8f), 9.0f);
DefaultRandom randomNumberGenerator = new DefaultRandom();
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector2 randomPoint = testDisc.RandomPointOnPerimeter(randomNumberGenerator);
Assert.That(
(testDisc.Center - randomPoint).Length(),
Is.EqualTo(testDisc.Radius).Within(36).Ulps
// TODO: This method suffers from accuracy problems!
);
}
}
public static float[,] Generate(int NumPoints = 0, float MinDist = -1f,
bool Circle = true, int NewPointsCount = 30)
{
if (MinDist <= 0.0f && NumPoints <= 0)
{
NumPoints = 2000;
}
if (MinDist <= 0.0f)
{
MinDist = (float)Math.Sqrt((float)NumPoints) / NumPoints;
}
if (NumPoints <= 0)
{
NumPoints = (int)(1 / (MinDist * MinDist));
}
var Generator = new DefaultRandom();
var SamplePoints = new List <Point>();
var ProcessList = new List <Point>();
// create the grid
float CellSize = MinDist / (float)Math.Sqrt(2.0f);
int GridW = (int)Math.Ceiling(1.0f / CellSize);
int GridH = (int)Math.Ceiling(1.0f / CellSize);
Grid Grid = new Grid(GridW, GridH, CellSize);
Point FirstPoint;
do
{
FirstPoint = new Point(Generator.RandomFloat(), Generator.RandomFloat());
} while (!(Circle ? FirstPoint.IsInCircle() : FirstPoint.IsInRectangle()));
// update containers
ProcessList.Add(FirstPoint);
SamplePoints.Add(FirstPoint);
Grid.Insert(FirstPoint);
// generate new points for each point in the queue
while (ProcessList.Count > 0 && SamplePoints.Count < NumPoints)
{
Point Point = PopRandom(ProcessList, Generator);
for (int i = 0; i < NewPointsCount; i++)
{
Point NewPoint = GenerateRandomPointAround(Point, MinDist, Generator);
bool Fits = Circle ? NewPoint.IsInCircle() : NewPoint.IsInRectangle();
if (Fits && !Grid.IsInNeighbourhood(NewPoint, MinDist, CellSize))
{
ProcessList.Add(NewPoint);
SamplePoints.Add(NewPoint);
Grid.Insert(NewPoint);
continue;
}
}
}
var result = new float[SamplePoints.Count, 2];
for (int i = 0; i < SamplePoints.Count; i++)
{
result[i, 0] = SamplePoints[i].x * 2 - 1;
result[i, 1] = SamplePoints[i].y * 2 - 1;
}
return(result);
}
private static Point PopRandom(List<Point> Points, DefaultRandom Generator)
{
int Idx = Generator.RandomInt(Points.Count - 1);
Point P = Points[Idx];
Points.RemoveAt(Idx);
return P;
}
public void DefaultRandom_ResultIsInRange0_10()
{
var uut = new DefaultRandom(0, 10);
Assert.That(uut.GetResult, Is.GreaterThanOrEqualTo(0).And.LessThan(10));
}
public static float[,] Generate(int NumPoints = 0, float MinDist = -1f,
bool Circle = true, int NewPointsCount = 30)
{
if (MinDist <= 0.0f && NumPoints <= 0)
NumPoints = 2000;
if (MinDist <= 0.0f)
MinDist = (float)Math.Sqrt((float)NumPoints) / NumPoints;
if (NumPoints <= 0)
NumPoints = (int)(1 / (MinDist * MinDist));
var Generator = new DefaultRandom();
var SamplePoints = new List<Point>();
var ProcessList = new List<Point>();
// create the grid
float CellSize = MinDist / (float)Math.Sqrt(2.0f);
int GridW = (int)Math.Ceiling(1.0f / CellSize);
int GridH = (int)Math.Ceiling(1.0f / CellSize);
Grid Grid = new Grid(GridW, GridH, CellSize);
Point FirstPoint;
do
{
FirstPoint = new Point(Generator.RandomFloat(), Generator.RandomFloat());
} while (!(Circle ? FirstPoint.IsInCircle() : FirstPoint.IsInRectangle()));
// update containers
ProcessList.Add(FirstPoint);
SamplePoints.Add(FirstPoint);
Grid.Insert(FirstPoint);
// generate new points for each point in the queue
while (ProcessList.Count > 0 && SamplePoints.Count < NumPoints)
{
Point Point = PopRandom(ProcessList, Generator);
for (int i = 0; i < NewPointsCount; i++)
{
Point NewPoint = GenerateRandomPointAround(Point, MinDist, Generator);
bool Fits = Circle ? NewPoint.IsInCircle() : NewPoint.IsInRectangle();
if (Fits && !Grid.IsInNeighbourhood(NewPoint, MinDist, CellSize))
{
ProcessList.Add(NewPoint);
SamplePoints.Add(NewPoint);
Grid.Insert(NewPoint);
continue;
}
}
}
var result = new float[SamplePoints.Count, 2];
for (int i = 0; i < SamplePoints.Count; i++)
{
result[i, 0] = SamplePoints[i].x * 2 - 1;
result[i, 1] = SamplePoints[i].y * 2 - 1;
}
return result;
}
public void TestRandomPointWithin() {
DefaultRandom random = new DefaultRandom();
AxisAlignedRectangle2 testRectangle = new AxisAlignedRectangle2(
new Vector2(12.3f, 45.6f), new Vector2(98.7f, 65.4f)
);
for(int index = 0; index < Specifications.ProbabilisticFunctionSamples; ++index) {
Vector2 randomPoint = testRectangle.RandomPointWithin(random);
Assert.AreEqual(testRectangle.ClosestPointTo(randomPoint), randomPoint);
}
}
public void TestRandomPointOnSurface() {
Sphere3 unitSphere = new Sphere3(Vector3.Zero, 1.0f);
Sphere3 innerSphere = new Sphere3(Vector3.Zero, 1.0f - Specifications.HullAccuracy);
Sphere3 outerSphere = new Sphere3(Vector3.Zero, 1.0f + Specifications.HullAccuracy);
DefaultRandom random = new DefaultRandom();
Vector3 total = Vector3.Zero;
for(int i = 0; i < Specifications.ProbabilisticFunctionSamples; ++i) {
Vector3 point = unitSphere.RandomPointOnSurface(random);
Assert.IsFalse(
innerSphere.Contains(point), "Random point lies on the sphere's hull"
);
Assert.IsTrue(
outerSphere.Contains(point), "Random point lies on the sphere's hull"
);
total += point;
}
total /= Specifications.ProbabilisticFunctionSamples;
Assert.AreEqual(
0.0f, total.X, Specifications.ProbabilisticFunctionDeviation,
"Random points average on the center of the sphere on the X axis"
);
Assert.AreEqual(
0.0f, total.Y, Specifications.ProbabilisticFunctionDeviation,
"Random points average on the center of the sphere on the Y axis"
);
Assert.AreEqual(
0.0f, total.Z, Specifications.ProbabilisticFunctionDeviation,
"Random points average on the center of the sphere on the Z axis"
);
}
private static Point GenerateRandomPointAround(Point P, float MinDist, DefaultRandom Generator )
{
// start with non-uniform distribution
float R1 = Generator.RandomFloat();
float R2 = Generator.RandomFloat();
// radius should be between MinDist and 2 * MinDist
float Radius = MinDist * (R1 + 1.0f);
// random angle
float Angle = 2 * 3.141592653589f * R2;
// the new point is generated around the point (x, y)
float X = (float)(P.x + Radius * Math.Cos(Angle));
float Y = (float)(P.y + Radius * Math.Sin(Angle));
return new Point(X, Y);
}
