public virtual void testEnvelope2000()
{
com.esri.core.geometry.Point[] points = new com.esri.core.geometry.Point[2000];
java.util.Random random = new java.util.Random(69);
for (int i = 0; i < 2000; i++)
{
points[i] = new com.esri.core.geometry.Point();
points[i].setX(random.nextDouble() * 100);
points[i].setY(random.nextDouble() * 100);
}
for (int iter = 0; iter < 2; iter++)
{
long startTime = Sharpen.Runtime.nanoTime();
com.esri.core.geometry.Envelope geomExtent = new com.esri.core.geometry.Envelope(
);
com.esri.core.geometry.Envelope fullExtent = new com.esri.core.geometry.Envelope(
);
for (int i_1 = 0; i_1 < 2000; i_1++)
{
points[i_1].queryEnvelope(geomExtent);
fullExtent.merge(geomExtent);
}
long endTime = Sharpen.Runtime.nanoTime();
}
}
public Maze(long paramLong, int w, int h)
{
java.util.Random localRandom = new java.util.Random(paramLong);
this.iteration = 0;
this.diagonal = false;
this.n_directions = 4;
//this.cde = new Key.Key_comparator();
//this.u = new TreeSet(this.cde);
this.u = new BinaryHeap(w * h);
this.size_x = w;
this.size_y = h;
this.cells = new Node[w, h];
for (int ii = 0; ii < w; ii++)
{
for (int jj = 0; jj < h; jj++)
{
this.cells[ii, jj] = new Node(ii, jj);
}
}
int i = (int)(localRandom.nextDouble() * 2147483647.0D) % w;
int j = (int)(localRandom.nextDouble() * 2147483647.0D) % h;
this.original_start = (this.robot_cell = this.start = this.cells[i, j]);
do
{
i = (int)(localRandom.nextDouble() * 2147483647.0D) % w;
j = (int)(localRandom.nextDouble() * 2147483647.0D) % h;
this.goal = this.cells[i, j];
} while ((this.start.X == this.goal.X) && (this.start.Y == this.goal.Y));
for (i = 0; i < w; i++)
{
for (j = 0; j < h; j++)
{
this.cells[i, j].h = (Math.Abs(i - this.goal.X) + Math.Abs(j - this.goal.Y));
this.cells[i, j].iteration = this.iteration;
if ((this.cells[i, j] == this.start) || (this.cells[i, j] == this.goal) ||
(localRandom.nextDouble() > 0.25D))
{
continue;
}
this.cells[i, j].real_type = 1;
}
}
}
public NoiseGeneratorPerlin(java.util.Random random)
{
permutations = new int[512];
xCoord = random.nextDouble() * 256D;
yCoord = random.nextDouble() * 256D;
zCoord = random.nextDouble() * 256D;
for (int i = 0; i < 256; i++)
{
permutations[i] = i;
}
for (int j = 0; j < 256; j++)
{
int k = random.nextInt(256 - j) + j;
int l = permutations[j];
permutations[j] = permutations[k];
permutations[k] = l;
permutations[j + 256] = permutations[j];
}
}
public override bool generate(World world, java.util.Random random, int i, int j, int k)
{
float f = random.nextFloat() * 3.141593F;
double d = (float)(i + 8) + (MathHelper.sin(f) * (float)numberOfBlocks) / 8F;
double d1 = (float)(i + 8) - (MathHelper.sin(f) * (float)numberOfBlocks) / 8F;
double d2 = (float)(k + 8) + (MathHelper.cos(f) * (float)numberOfBlocks) / 8F;
double d3 = (float)(k + 8) - (MathHelper.cos(f) * (float)numberOfBlocks) / 8F;
double d4 = (j + random.nextInt(3)) - 2;
double d5 = (j + random.nextInt(3)) - 2;
for (int l = 0; l <= numberOfBlocks; l++)
{
double d6 = d + ((d1 - d) * (double)l) / (double)numberOfBlocks;
double d7 = d4 + ((d5 - d4) * (double)l) / (double)numberOfBlocks;
double d8 = d2 + ((d3 - d2) * (double)l) / (double)numberOfBlocks;
double d9 = (random.nextDouble() * (double)numberOfBlocks) / 16D;
double d10 = (double)(MathHelper.sin(((float)l * 3.141593F) / (float)numberOfBlocks) + 1.0F) * d9 + 1.0D;
double d11 = (double)(MathHelper.sin(((float)l * 3.141593F) / (float)numberOfBlocks) + 1.0F) * d9 + 1.0D;
int i1 = MathHelper.floor_double(d6 - d10 / 2D);
int j1 = MathHelper.floor_double(d7 - d11 / 2D);
int k1 = MathHelper.floor_double(d8 - d10 / 2D);
int l1 = MathHelper.floor_double(d6 + d10 / 2D);
int i2 = MathHelper.floor_double(d7 + d11 / 2D);
int j2 = MathHelper.floor_double(d8 + d10 / 2D);
for (int k2 = i1; k2 <= l1; k2++)
{
double d12 = (((double)k2 + 0.5D) - d6) / (d10 / 2D);
if (d12 * d12 >= 1.0D)
{
continue;
}
for (int l2 = j1; l2 <= i2; l2++)
{
double d13 = (((double)l2 + 0.5D) - d7) / (d11 / 2D);
if (d12 * d12 + d13 * d13 >= 1.0D)
{
continue;
}
for (int i3 = k1; i3 <= j2; i3++)
{
double d14 = (((double)i3 + 0.5D) - d8) / (d10 / 2D);
if (d12 * d12 + d13 * d13 + d14 * d14 < 1.0D && world.GetBlock(k2, l2, i3) == (byte)Blocks.Stone)
{
world.SetBlock(k2, l2, i3, (byte)minableBlockId);
}
}
}
}
}
return(true);
}
public override double NextDouble()
{
return(r.nextDouble());
}
public override bool generate(World world, java.util.Random random, int i, int j, int k)
{
i -= 8;
for (k -= 8; j > 0 && world.IsAirBlock(i, j, k); j--)
{
}
j -= 4;
bool[] aflag = new bool[2048];
int l = random.nextInt(4) + 4;
for (int i1 = 0; i1 < l; i1++)
{
double d = random.nextDouble() * 6D + 3D;
double d1 = random.nextDouble() * 4D + 2D;
double d2 = random.nextDouble() * 6D + 3D;
double d3 = random.nextDouble() * (16D - d - 2D) + 1.0D + d / 2D;
double d4 = random.nextDouble() * (8D - d1 - 4D) + 2D + d1 / 2D;
double d5 = random.nextDouble() * (16D - d2 - 2D) + 1.0D + d2 / 2D;
for (int j4 = 1; j4 < 15; j4++)
{
for (int k4 = 1; k4 < 15; k4++)
{
for (int l4 = 1; l4 < 7; l4++)
{
double d6 = ((double)j4 - d3) / (d / 2D);
double d7 = ((double)l4 - d4) / (d1 / 2D);
double d8 = ((double)k4 - d5) / (d2 / 2D);
double d9 = d6 * d6 + d7 * d7 + d8 * d8;
if (d9 < 1.0D)
{
aflag[(j4 * 16 + k4) * 8 + l4] = true;
}
}
}
}
}
for (int j1 = 0; j1 < 16; j1++)
{
for (int j2 = 0; j2 < 16; j2++)
{
for (int j3 = 0; j3 < 8; j3++)
{
bool flag = !aflag[(j1 * 16 + j2) * 8 + j3] && (j1 < 15 && aflag[((j1 + 1) * 16 + j2) * 8 + j3] || j1 > 0 && aflag[((j1 - 1) * 16 + j2) * 8 + j3] || j2 < 15 && aflag[(j1 * 16 + (j2 + 1)) * 8 + j3] || j2 > 0 && aflag[(j1 * 16 + (j2 - 1)) * 8 + j3] || j3 < 7 && aflag[(j1 * 16 + j2) * 8 + (j3 + 1)] || j3 > 0 && aflag[(j1 * 16 + j2) * 8 + (j3 - 1)]);
if (!flag)
{
continue;
}
byte block = world.GetBlock(i + j1, j + j3, k + j2);
if (j3 >= 4 && BlockData.IsLiquid(block))
{
return(false);
}
if (j3 < 4 && !BlockData.IsSolid(block) && world.GetBlock(i + j1, j + j3, k + j2) != blockIndex)
{
return(false);
}
}
}
}
for (int k1 = 0; k1 < 16; k1++)
{
for (int k2 = 0; k2 < 16; k2++)
{
for (int k3 = 0; k3 < 8; k3++)
{
if (aflag[(k1 * 16 + k2) * 8 + k3])
{
world.SetBlock(i + k1, j + k3, k + k2, (byte)(k3 < 4 ? blockIndex : 0));
}
}
}
}
for (int l1 = 0; l1 < 16; l1++)
{
for (int l2 = 0; l2 < 16; l2++)
{
for (int l3 = 4; l3 < 8; l3++)
{
if (aflag[(l1 * 16 + l2) * 8 + l3] && world.GetBlock(i + l1, (j + l3) - 1, k + l2) == (byte)Blocks.Dirt /*&& world.getSavedLightValue(EnumSkyBlock.Sky, i + l1, j + l3, k + l2) > 0*/) // TODO: Lighting stuffs!
{
world.SetBlock(i + l1, (j + l3) - 1, k + l2, (byte)Blocks.Grass);
}
}
}
}
if (BlockData.BlockMaterial((byte)blockIndex) == Material.Lava)
{
for (int i2 = 0; i2 < 16; i2++)
{
for (int i3 = 0; i3 < 16; i3++)
{
for (int i4 = 0; i4 < 8; i4++)
{
bool flag1 = !aflag[(i2 * 16 + i3) * 8 + i4] && (i2 < 15 && aflag[((i2 + 1) * 16 + i3) * 8 + i4] || i2 > 0 && aflag[((i2 - 1) * 16 + i3) * 8 + i4] || i3 < 15 && aflag[(i2 * 16 + (i3 + 1)) * 8 + i4] || i3 > 0 && aflag[(i2 * 16 + (i3 - 1)) * 8 + i4] || i4 < 7 && aflag[(i2 * 16 + i3) * 8 + (i4 + 1)] || i4 > 0 && aflag[(i2 * 16 + i3) * 8 + (i4 - 1)]);
if (flag1 && (i4 < 4 || random.nextInt(2) != 0) && BlockData.IsSolid(world.GetBlock(i + i2, j + i4, k + i3)))
{
world.SetBlock(i + i2, j + i4, k + i3, (byte)Blocks.Stone);
}
}
}
}
}
return(true);
}
public void replaceBlocksForBiome(int i, int j, byte[] abyte0, BiomeGenBase[] abiomegenbase)
{
byte byte0 = 63;
double d = 0.03125D;
stoneNoise = field_702_n.GetNoise(stoneNoise, i * 16, j * 16, 0, 16, 16, 1, d * 2D, d * 2D, d * 2D);
for (int k = 0; k < 16; k++)
{
for (int l = 0; l < 16; l++)
{
BiomeGenBase biomegenbase = abiomegenbase[l + k * 16];
int i1 = (int)(stoneNoise[k + l * 16] / 3D + 3D + random.nextDouble() * 0.25D);
int j1 = -1;
byte byte1 = biomegenbase.topBlock;
byte byte2 = biomegenbase.fillerBlock;
for (int k1 = 127; k1 >= 0; k1--)
{
int l1 = (l * 16 + k) * 128 + k1;
if (k1 <= 0 + random.nextInt(5))
{
abyte0[l1] = (byte)Blocks.Bedrock;
continue;
}
byte byte3 = abyte0[l1];
if (byte3 == 0)
{
j1 = -1;
continue;
}
if (byte3 != (byte)Blocks.Stone)
{
continue;
}
if (j1 == -1)
{
if (i1 <= 0)
{
byte1 = 0;
byte2 = (byte)Blocks.Stone;
}
else
if (k1 >= byte0 - 4 && k1 <= byte0 + 1)
{
byte1 = biomegenbase.topBlock;
byte2 = biomegenbase.fillerBlock;
}
if (k1 < byte0 && byte1 == 0)
{
byte1 = (byte)Blocks.SWater;
}
j1 = i1;
if (k1 >= byte0 - 1)
{
abyte0[l1] = byte1;
}
else
{
abyte0[l1] = byte2;
}
continue;
}
if (j1 <= 0)
{
continue;
}
j1--;
abyte0[l1] = byte2;
if (j1 == 0 && byte2 == (byte)Blocks.Sand)
{
j1 = random.nextInt(4);
byte2 = (byte)Blocks.SandStone;
}
}
}
}
}
protected virtual double Sample() => _random.nextDouble();
