public void GenerateStringTypeTests()
{
FastRandom fr = new FastRandom();
CharacterType[] types = new CharacterType[] { CharacterType.LowerCase, CharacterType.UpperCase, CharacterType.Numeric };
Func<char, bool>[] actions = new Func<char, bool>[] { Char.IsLower, Char.IsUpper, Char.IsNumber };
for(int i = 0; i < types.Length; i++)
{
for(int j = 0; j < 1000; j++)
{
var s = fr.NextString(5, types[i]);
Assert.Equal(5, s.Length);
foreach(var c in s)
{
Assert.True(actions[i](c));
}
}
}
{
var s = fr.NextString(5, CharacterType.Special);
Assert.Equal(5, s.Length);
foreach(var c in s)
{
Assert.True(FastRandom.SpecialCharacters.Contains(c));
}
}
}
public Desert(short x, short z, FastRandom rnd)
: base(x, z, rnd)
{
CreateChunk();
base.CreateChunk();
base.CreateOres();
base.CreateLakes(DefaultHeigth - 1);
CreateHills();
CreateCacti();
}
public void GenerateNumberTest()
{
var min = 5; var max = 10;
FastRandom fr = new FastRandom();
for(int i = 0; i < 10000; i++)
{
var v = fr.Next(min, max);
if(v < min || v >= max) Assert.True(false, v.ToString());
}
}
/**
* @param seed
*/
public PerlinNoise(long seed)
{
FastRandom rand = new FastRandom(seed);
_noisePermutations = new int[512];
_noiseTable = new int[256];
for (int i = 0; i < 256; i++)
_noiseTable[i] = i;
for (int i = 0; i < 256; i++) {
int j = rand.randomInt() % 256;
j = (j < 0) ? -j : j;
int swap = _noiseTable[i];
_noiseTable[i] = _noiseTable[j];
_noiseTable[j] = swap;
}
for (int i = 0; i < 256; i++)
_noisePermutations[i] = _noisePermutations[i + 256] = _noiseTable[i];
}
public Biome(short x, short z, FastRandom rnd)
: base(x, z)
{
X_Start = x * 10 * 64;
Z_Start = z * 10 * 64;
X_End = (x + 1) * 10 * 64;
Z_End = (z + 1) * 10 * 64;
RandomGenerator = rnd;
DefaultHeigth = 64;//Has to be a multiple of 2's 4's 8's 16's
base.IsAir = new bool[Depth / 16];
int i = 0;
for (; i < DefaultHeigth / 16; i++)
{
IsAir[i] = false;
}
for (; i < Depth / 16; i++)
{
IsAir[i] = true;
}
}
private void InitGen()
{
if (GenInit)
return;
GenInit = true;
_Gen1 = new PerlinNoise(_Seed);
_Gen2 = new PerlinNoise(_Seed + 1);
_Gen3 = new PerlinNoise(_Seed + 2);
_Gen4 = new PerlinNoise(_Seed + 3);
_Gen5 = new PerlinNoise(_Seed + 4);
_Gen6 = new PerlinNoise(_Seed + 5);
_FastRandom = new FastRandom(_Seed);
}
private Boolean[,] GoGenerate(FastRandom r, int width, int height)
{
int x = 1;
int y = 1;
var map = new Boolean[width, height];
//The length of this array is just enough to fit the longest path possible
int[] stackjex = new int[width * height / 4];
int[] stackjey = new int[width * height / 4];
int pointertje = 0;
stackjex[pointertje] = x;
stackjey[pointertje] = y;
pointertje++;
map[x, y] = true;
//pixelChangedCallback.Invoke(x, y, currentStep, totSteps);
MazePoint[] targets = new MazePoint[4];
//form.drawPixel(x, y, brushThisUses);
while (pointertje > 0)
{
x = stackjex[pointertje - 1];
y = stackjey[pointertje - 1];
int targetCount = 0;
if (x - 2 > 0 && !map[x - 2, y])
{
targets[targetCount].X = x - 2;
targets[targetCount].Y = y;
targetCount++;
}
if (x + 2 < width - 1 && !map[x + 2, y])
{
targets[targetCount].X = x + 2;
targets[targetCount].Y = y;
targetCount++;
}
if (y - 2 > 0 && !map[x, y - 2])
{
targets[targetCount].X = x;
targets[targetCount].Y = y - 2;
targetCount++;
}
if (y + 2 < height - 1 && !map[x, y + 2])
{
targets[targetCount].X = x;
targets[targetCount].Y = y + 2;
targetCount++;
}
//Thread.Sleep(1000);
if (targetCount > 0)
{
var target = targets[r.Next(targetCount)];
stackjex[pointertje] = target.X;
stackjey[pointertje] = target.Y;
pointertje++;
map[target.X, target.Y] = true;
if (target.X < x)
{
map[x - 1, y] = true;
//pixelChangedCallback.Invoke(x - 1, y, currentStep, totSteps);
//form.drawPixel(x - 1, y, brushThisUses);
}
else if (target.X > x)
{
map[x + 1, y] = true;
//pixelChangedCallback.Invoke(x + 1, y, currentStep, totSteps);
//form.drawPixel(x + 1, y, brushThisUses);
}
else if (target.Y < y)
{
map[x, y - 1] = true;
//pixelChangedCallback.Invoke(x, y - 1, currentStep, totSteps);
//form.drawPixel(x, y - 1, brushThisUses);
}
else if (target.Y > y)
{
map[x, y + 1] = true;
//pixelChangedCallback.Invoke(x, y + 1, currentStep, totSteps);
//form.drawPixel(x, y + 1, brushThisUses);
}
//pixelChangedCallback.Invoke(target.X, target.Y, currentStep, totSteps);
//form.drawPixel(target.X, target.Y, brushThisUses);
}
else
{
pointertje--;
}
}
return map;
}
private Boolean[,] GoGenerate(FastRandom r, int width, int height)
{
int x = 1;
int y = 1;
var map = new Boolean[width, height];
List<int> stackjex = new List<int>(10000);
List<int> stackjey = new List<int>(10000);
int pointertje = 0;
stackjex.Add(x);
stackjey.Add(y);
pointertje++;
map[x, y] = true;
//pixelChangedCallback.Invoke(x, y, currentStep, totSteps);
MazePoint[] targets = new MazePoint[4];
//form.drawPixel(x, y, brushThisUses);
while (pointertje > 0)
{
x = stackjex[pointertje - 1];
y = stackjey[pointertje - 1];
int targetCount = 0;
if (x - 2 > 0 && !map[x - 2, y])
{
targets[targetCount].X = x - 2;
targets[targetCount].Y = y;
targetCount++;
}
if (x + 2 < width - 1 && !map[x + 2, y])
{
targets[targetCount].X = x + 2;
targets[targetCount].Y = y;
targetCount++;
}
if (y - 2 > 0 && !map[x, y - 2])
{
targets[targetCount].X = x;
targets[targetCount].Y = y - 2;
targetCount++;
}
if (y + 2 < height - 1 && !map[x, y + 2])
{
targets[targetCount].X = x;
targets[targetCount].Y = y + 2;
targetCount++;
}
//Thread.Sleep(1000);
if (targetCount > 0)
{
var target = targets[r.Next(targetCount)];
if (pointertje == stackjex.Count)
{
stackjex.Add(target.X);
stackjey.Add(target.Y);
}
else
{
stackjex[pointertje] = target.X;
stackjey[pointertje] = target.Y;
}
pointertje++;
map[target.X, target.Y] = true;
if (target.X < x)
{
map[x - 1, y] = true;
//pixelChangedCallback.Invoke(x - 1, y, currentStep, totSteps);
//form.drawPixel(x - 1, y, brushThisUses);
}
else if (target.X > x)
{
map[x + 1, y] = true;
//pixelChangedCallback.Invoke(x + 1, y, currentStep, totSteps);
//form.drawPixel(x + 1, y, brushThisUses);
}
else if (target.Y < y)
{
map[x, y - 1] = true;
//pixelChangedCallback.Invoke(x, y - 1, currentStep, totSteps);
//form.drawPixel(x, y - 1, brushThisUses);
}
else if (target.Y > y)
{
map[x, y + 1] = true;
//pixelChangedCallback.Invoke(x, y + 1, currentStep, totSteps);
//form.drawPixel(x, y + 1, brushThisUses);
}
//pixelChangedCallback.Invoke(target.X, target.Y, currentStep, totSteps);
//form.drawPixel(target.X, target.Y, brushThisUses);
}
else
{
pointertje--;
}
}
return map;
}
static void getBounds2D(int[,] bounds, int tolerance, int[,] seed, uint xx, uint yy, int depth, int min, int max)
{
int[,] data = new int[3, 3];
int[,] seeds = new int[3, 3];
data[0, 0] = bounds[0, 0];
data[2, 0] = bounds[1, 0];
data[0, 2] = bounds[0, 1];
data[2, 2] = bounds[1, 1];
seeds[0, 0] = seed[0, 0];
seeds[2, 0] = seed[1, 0];
seeds[0, 2] = seed[0, 1];
seeds[2, 2] = seed[1, 1];
FastRandom r = new FastRandom();
r.Reinitialise(seeds[2, 0] + depth);
r.Next();
r.Next();
int l = seeds[2, 1] = r.Next();
l = toggleMode((data[2, 0] + data[2, 2]) / 2, l, tolerance, min, max);
data[2, 1] = l;
r.Reinitialise(seeds[0, 2] + depth);
r.Next();
int u = seeds[1, 2] = r.Next();
u = toggleMode((data[0, 2] + data[2, 2]) / 2, u, tolerance, min, max);
data[1, 2] = u;
r.Reinitialise(seeds[0, 0] + depth);
int ul = data[0, 0];
int ur = data[2, 0];
int dl = data[0, 2];
int dr = data[2, 2];
int m = seeds[1, 1] = r.Next();
u = seeds[1, 0] = r.Next();
l = seeds[0, 1] = r.Next();
m = toggleMode((ul + ur + dl + dr) / 4, m, tolerance, min, max);
u = toggleMode((ul + ur) / 2, u, tolerance, min, max);
l = toggleMode((ul + dl) / 2, l, tolerance, min, max);
data[1, 1] = m;
data[1, 0] = u;
data[0, 1] = l;
bounds[0, 0] = data[xx, yy];
bounds[1, 0] = data[xx + 1, yy];
bounds[0, 1] = data[xx, yy + 1];
bounds[1, 1] = data[xx + 1, yy + 1];
seed[0, 0] = seeds[xx, yy];
seed[1, 0] = seeds[xx + 1, yy];
seed[0, 1] = seeds[xx, yy + 1];
seed[1, 1] = seeds[xx + 1, yy + 1];
return;
}
static int[, ,] getFrame3D(int[, ,] buffer, int x, int y, int z, int d, int seed, int tolerance)
{
int[, ,] seeds = new int[2, 2, 2];
int[, ,] e = new int[2, 2, 2];
FastRandom random = new FastRandom(seed);
for (int xx = 0; xx < 2; xx++)
for (int yy = 0; yy < 2; yy++)
for (int zz = 0; zz < 2; zz++)
{
seeds[xx, yy, zz] = random.Next() + xx + 2 * yy + 4 * zz;
e[xx, yy, zz] = buffer[x + 2 * xx * d, y + 2 * yy * d, z + 2 * zz * d];
}
Func<int, int> delta = i => i + (random.Next() % tolerance) - (tolerance / 2);
//center cube
buffer[x + d, y + d, z + d] = delta((
e[0, 0, 0] +
e[0, 0, 1] +
e[0, 1, 0] +
e[0, 1, 1] +
e[1, 0, 0] +
e[1, 0, 1] +
e[1, 1, 0] +
e[1, 1, 1]) / 8);
//center face
buffer[x, y + d, z + d] = delta((
e[0, 0, 0] +
e[0, 0, 1] +
e[0, 1, 0] +
e[0, 1, 1]) / 4);
buffer[x + 2 * d, y + d, z + d] = delta((
e[1, 0, 0] +
e[1, 0, 1] +
e[1, 1, 0] +
e[1, 1, 1]) / 4);
buffer[x + d, y, z + d] = delta((
e[0, 0, 0] +
e[0, 0, 1] +
e[1, 0, 0] +
e[1, 0, 1]) / 4);
buffer[x + d, y + 2 * d, z + d] = delta((
e[0, 1, 0] +
e[0, 1, 1] +
e[1, 1, 0] +
e[1, 1, 1]) / 4);
buffer[x + d, y + d, z] = delta((
e[0, 0, 0] +
e[0, 1, 0] +
e[1, 0, 0] +
e[1, 1, 0]) / 4);
buffer[x + d, y + d, z + 2 * d] = delta((
e[0, 0, 1] +
e[0, 1, 1] +
e[1, 0, 1] +
e[1, 1, 1]) / 4);
//center line
buffer[x, y, z + d] = delta((e[0, 0, 0] + e[0, 0, 1]) / 2);
buffer[x + 2 * d, y, z + d] = delta((e[1, 0, 0] + e[1, 0, 1]) / 2);
buffer[x, y + 2 * d, z + d] = delta((e[0, 1, 0] + e[0, 1, 1]) / 2);
buffer[x + 2 * d, y + 2 * d, z + d] = delta((e[1, 1, 0] + e[1, 1, 1]) / 2);
buffer[x, y + d, z] = delta((e[0, 0, 0] + e[0, 1, 0]) / 2);
buffer[x + 2 * d, y + d, z] = delta((e[1, 0, 0] + e[1, 1, 0]) / 2);
buffer[x, y + d, z + 2 * d] = delta((e[0, 0, 1] + e[0, 1, 1]) / 2);
buffer[x + 2 * d, y + d, z + 2 * d] = delta((e[1, 0, 1] + e[1, 1, 1]) / 2);
buffer[x + d, y, z] = delta((e[0, 0, 0] + e[1, 0, 0]) / 2);
buffer[x + d, y + 2 * d, z] = delta((e[0, 1, 0] + e[1, 1, 0]) / 2);
buffer[x + d, y, z + 2 * d] = delta((e[0, 0, 1] + e[1, 0, 1]) / 2);
buffer[x + d, y + 2 * d, z + 2 * d] = delta((e[0, 1, 1] + e[1, 1, 1]) / 2);
return seeds;
}
static int[,] getData2D(int[,] bounds, int depth, int tolerance, int[,] seed, int sizeExp, int min, int max)
{
int totalSize, segmentSize, count = 1;
totalSize = segmentSize = 1 << depth;
int[,] data = new int[totalSize + 1, totalSize + 1];
int[,] seeds = new int[totalSize + 1, totalSize + 1];
data[0, 0] = bounds[0, 0];
data[totalSize, 0] = bounds[1, 0];
data[0, totalSize] = bounds[0, 1];
data[totalSize, totalSize] = bounds[1, 1];
seeds[0, 0] = seed[0, 0];
seeds[totalSize, 0] = seed[1, 0];
seeds[0, totalSize] = seed[0, 1];
seeds[totalSize, totalSize] = seed[1, 1];
FastRandom r = new FastRandom();
while (segmentSize != 1)
{
for (int y = 0; y < count; y++)
{
r.Reinitialise(seeds[totalSize, y * segmentSize] + sizeExp);
int ul = data[totalSize, y * segmentSize];
int dl = data[totalSize, (y + 1) * segmentSize];
r.Next();
r.Next();
int l = seeds[totalSize, y * segmentSize + segmentSize / 2] = r.Next();
l = toggleMode((ul + dl) / 2, l, tolerance, min, max);
data[totalSize, y * segmentSize + segmentSize / 2] = l;
}
for (int x = 0; x < count; x++)
{
r.Reinitialise(seeds[x * segmentSize, totalSize] + sizeExp);
int ul = data[x * segmentSize, totalSize];
int ur = data[(x + 1) * segmentSize, totalSize];
r.Next();
int u = seeds[x * segmentSize + segmentSize / 2, totalSize] = r.Next();
u = toggleMode((ul + ur) / 2 ,u, tolerance, min, max);
data[x * segmentSize + segmentSize / 2, totalSize] = u;
}
for (int y = 0; y < count; y++)
for (int x = 0; x < count; x++)
{
r.Reinitialise(seeds[x * segmentSize, y * segmentSize] + sizeExp);
int ul = data[x * segmentSize, y * segmentSize];
int ur = data[(x + 1) * segmentSize, y * segmentSize];
int dl = data[x * segmentSize, (y + 1) * segmentSize];
int dr = data[(x + 1) * segmentSize, (y + 1) * segmentSize];
int m = seeds[x * segmentSize + segmentSize / 2, y * segmentSize + segmentSize / 2] = r.Next();
int u = seeds[x * segmentSize + segmentSize / 2, y * segmentSize] = r.Next();
int l = seeds[x * segmentSize, y * segmentSize + segmentSize / 2] = r.Next();
m = toggleMode((ul + ur + dl + dr) / 4, m, tolerance, min, max);
u = toggleMode((ul + ur) / 2, u, tolerance, min, max);
l = toggleMode((ul + dl) / 2, l, tolerance, min, max);
data[x * segmentSize + segmentSize / 2, y * segmentSize + segmentSize / 2] = m;
data[x * segmentSize + segmentSize / 2, y * segmentSize] = u;
data[x * segmentSize, y * segmentSize + segmentSize / 2] = l;
}
tolerance = getTolerance(tolerance);
segmentSize /= 2;
count *= 2;
sizeExp--;
}
return data;
}
