Merge branch 'master' into test

test
mckuhei 6 months ago
commit a0247b12a0

@ -1,6 +1,8 @@
import java.io.File;
import java.lang.reflect.Field;
import javax.imageio.ImageIO;
import net.minecraft.client.Minecraft;
public class Start
@ -21,4 +23,8 @@ public class Start
Minecraft.main(args);
}
static {
ImageIO.setUseCache(false);
}
}

@ -98,80 +98,83 @@ public class ChunkProviderGenerate implements IChunkProvider
*/
public void generateTerrain(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte)
{
byte var4 = 4;
byte var5 = 32;
byte var6 = 63;
int var7 = var4 + 1;
byte var8 = 33;
int var9 = var4 + 1;
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), par2.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), var7 + 5, var9 + 5);
this.noiseArray = this.initializeNoiseField(this.noiseArray, par1.multiply(BigInteger.valueOf(var4)), 0, par2.multiply(BigInteger.valueOf(var4)), var7, var8, var9, 17);
for (int var10 = 0; var10 < var4; ++var10)
byte width1 = 4;
byte height1 = 32;
byte seaLevel = 63;
// int var7 = var4 + 1;
byte noiseHeight = 33;
int noiseWidth = width1 + 1;
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), par2.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), noiseWidth + 5, noiseWidth + 5);
this.noiseArray = this.initializeNoiseField(this.noiseArray, par1.multiply(BigInteger.valueOf(width1)), 0, par2.multiply(BigInteger.valueOf(width1)), noiseWidth, noiseHeight, noiseWidth, 17);
// Scan blocks...
for (int x1 = 0; x1 < width1; ++x1)
{
for (int var11 = 0; var11 < var4; ++var11)
for (int z1 = 0; z1 < width1; ++z1)
{
for (int var12 = 0; var12 < var5; ++var12)
for (int y1 = 0; y1 < height1; ++y1)
{
double var13 = 0.125D;
double var15 = this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];
double var17 = this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];
double var19 = this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];
double var21 = this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];
double var23 = (this.noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;
double var25 = (this.noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;
double var27 = (this.noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;
double var29 = (this.noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;
for (int var31 = 0; var31 < 8; ++var31)
// Who is faster? Is LOAD faster or LDC faster?
double step8 = 0.125D;
// Evil gradient variables.
double AA = this.noiseArray[((x1 + 0) * noiseWidth + z1 + 0) * noiseHeight + y1 + 0];
double BB = this.noiseArray[((x1 + 0) * noiseWidth + z1 + 1) * noiseHeight + y1 + 0];
double CC = this.noiseArray[((x1 + 1) * noiseWidth + z1 + 0) * noiseHeight + y1 + 0];
double DD = this.noiseArray[((x1 + 1) * noiseWidth + z1 + 1) * noiseHeight + y1 + 0];
double stepAA = (this.noiseArray[((x1 + 0) * noiseWidth + z1 + 0) * noiseHeight + y1 + 1] - AA) * step8; // Use 0.125D instead of step8 may faster???
double stepBB = (this.noiseArray[((x1 + 0) * noiseWidth + z1 + 1) * noiseHeight + y1 + 1] - BB) * step8;
double stepCC = (this.noiseArray[((x1 + 1) * noiseWidth + z1 + 0) * noiseHeight + y1 + 1] - CC) * step8;
double stepDD = (this.noiseArray[((x1 + 1) * noiseWidth + z1 + 1) * noiseHeight + y1 + 1] - DD) * step8;
for (int y2 = 0; y2 < 8; ++y2)
{
double var32 = 0.25D;
double var34 = var15;
double var36 = var17;
double var38 = (var19 - var15) * var32;
double var40 = (var21 - var17) * var32;
double step4 = 0.25D;
double EE = AA;
double FF = BB;
double stepEE = (CC - AA) * step4;
double stepFF = (DD - BB) * step4;
for (int var42 = 0; var42 < 4; ++var42)
for (int x2 = 0; x2 < 4; ++x2)
{
int var43 = var42 + var10 * 4 << 12 | 0 + var11 * 4 << 8 | var12 * 8 + var31;
short var44 = 256;
var43 -= var44;
double var45 = 0.25D;
double var49 = (var36 - var34) * var45;
double var47 = var34 - var49;
for (int var51 = 0; var51 < 4; ++var51)
int xzy = x2 + x1 * 4 << 12 | 0 + z1 * 4 << 8 | y1 * 8 + y2;
short height = 256;
xzy -= height;
// double var45 = 0.25D;
double stepGG = (FF - EE) * step4;
double GG = EE - stepGG;
for (int z2 = 0; z2 < 4; ++z2)
{
if(!ENABLE_FRINGE_LAND) {
var47 += var49;
GG += stepGG;
} else {
if(var51 == 0) var47 = var34;
if(z2 == 0) GG = EE;
}
if (var47 > 0.0D)
if (GG > 0.0D)
{
par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID;
par3ArrayOfByte[xzy += height] = (byte)Block.stone.blockID;
}
else if (var12 * 8 + var31 < var6)
else if (y1 * 8 + y2 < seaLevel)
{
par3ArrayOfByte[var43 += var44] = (byte)Block.waterStill.blockID;
par3ArrayOfByte[xzy += height] = (byte)Block.waterStill.blockID;
}
else
{
par3ArrayOfByte[var43 += var44] = 0;
par3ArrayOfByte[xzy += height] = 0;
}
if(ENABLE_FRINGE_LAND) {
var47 += var49;
GG += stepGG;
}
}
var34 += var38;
var36 += var40;
EE += stepEE;
FF += stepFF;
}
var15 += var23;
var17 += var25;
var19 += var27;
var21 += var29;
AA += stepAA;
BB += stepBB;
CC += stepCC;
DD += stepDD;
}
}
}
@ -327,11 +330,11 @@ public class ChunkProviderGenerate implements IChunkProvider
* generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
* size.
*/
private double[] initializeNoiseField(double[] par1ArrayOfDouble, BigInteger par2, int par3, BigInteger par4, int par5, int par6, int par7, int par8)
private double[] initializeNoiseField(double[] noiseTable, BigInteger x, int y, BigInteger z, int width, int depth, int height, int par8)
{
if (par1ArrayOfDouble == null)
if (noiseTable == null)
{
par1ArrayOfDouble = new double[par5 * par6 * par7];
noiseTable = new double[width * depth * height];
}
if (this.parabolicField == null)
@ -348,33 +351,33 @@ public class ChunkProviderGenerate implements IChunkProvider
}
}
double var44 = 684.412D;
double var45 = 684.412D;
this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, -par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);
this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, -par3, par4, par5, par6, par7, var44, var45, var44);
this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, -par3, par4, par5, par6, par7, var44, var45, var44);
double scaleX = 684.412D;
double scaleY = 684.412D;
this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, x, z, width, height, 1.121D, 1.121D, 0.5D);
this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, x, z, width, height, 200.0D, 200.0D, 0.5D);
this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, x, -y, z, width, depth, height, scaleX / 80.0D, scaleY / 160.0D, scaleX / 80.0D);
this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, x, -y, z, width, depth, height, scaleX, scaleY, scaleX);
this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, x, -y, z, width, depth, height, scaleX, scaleY, scaleX);
boolean var43 = false;
boolean var42 = false;
int var12 = 0;
int var13 = 0;
for (int var14 = 0; var14 < par5; ++var14)
for (int var14 = 0; var14 < width; ++var14)
{
for (int var15 = 0; var15 < par7; ++var15)
for (int var15 = 0; var15 < height; ++var15)
{
float var16 = 0.0F;
float var17 = 0.0F;
float maxHeight = 0.0F;
float minHeight = 0.0F;
float var18 = 0.0F;
byte var19 = 2;
BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)];
BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (width + 5)];
for (int var21 = -var19; var21 <= var19; ++var21)
{
for (int var22 = -var19; var22 <= var19; ++var22)
{
BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)];
BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (width + 5)];
float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F);
if (var23.minHeight > var20.minHeight)
@ -382,16 +385,16 @@ public class ChunkProviderGenerate implements IChunkProvider
var24 /= 2.0F;
}
var16 += var23.maxHeight * var24;
var17 += var23.minHeight * var24;
maxHeight += var23.maxHeight * var24;
minHeight += var23.minHeight * var24;
var18 += var24;
}
}
var16 /= var18;
var17 /= var18;
var16 = var16 * 0.9F + 0.1F;
var17 = (var17 * 4.0F - 1.0F) / 8.0F;
maxHeight /= var18;
minHeight /= var18;
maxHeight = maxHeight * 0.9F + 0.1F;
minHeight = (minHeight * 4.0F - 1.0F) / 8.0F;
double var46 = this.noise6[var13] / 8000.0D;
if (var46 < 0.0D)
@ -425,14 +428,14 @@ public class ChunkProviderGenerate implements IChunkProvider
++var13;
double var48 = (double)var17;
double var26 = (double)var16;
double var48 = (double)minHeight;
double var26 = (double)maxHeight;
var48 += var46 * 0.2D;
var48 = var48 * (double)par8 / 16.0D;
double var28 = (double)par8 / 2.0D + var48 * 4.0D - par3;
double var28 = (double)par8 / 2.0D + var48 * 4.0D - y;
double var30 = 0.0D;
for (int var47 = 0; var47 < par6; ++var47)
for (int var47 = 0; var47 < depth; ++var47)
{
double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26;
@ -460,19 +463,19 @@ public class ChunkProviderGenerate implements IChunkProvider
var30 -= var32;
if (var47 > par6 - 4)
if (var47 > depth - 4)
{
double var40 = (double)((float)(var47 - (par6 - 4)) / 3.0F);
double var40 = (double)((float)(var47 - (depth - 4)) / 3.0F);
var30 = var30 * (1.0D - var40) + -10.0D * var40;
}
par1ArrayOfDouble[var12] = var30;
noiseTable[var12] = var30;
++var12;
}
}
}
return par1ArrayOfDouble;
return noiseTable;
}
// FIXME

@ -141,6 +141,11 @@ public class MathHelper
{
return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0);
}
public static double clamp_double(double par0, double par1, double par2)
{
return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0);
}
/**
* Maximum of the absolute value of two numbers.

@ -128,13 +128,14 @@ public class NetServerHandler extends NetHandler
if (!this.field_72587_r)
{
// var3 = par1Packet10Flying.yPosition - this.lastPosY;
//
// if (par1Packet10Flying.xPosition.compareTo(this.lastPosX) == 0 && var3 * var3 < 0.01D && par1Packet10Flying.zPosition.compareTo(this.lastPosZ) == 0)
// {
// this.field_72587_r = true;
// }
this.field_72587_r = true;
var3 = par1Packet10Flying.yPosition - this.lastPosY;
if (par1Packet10Flying.xPosition.compareTo(this.lastPosX) == 0 && var3 * var3 < 0.01D && par1Packet10Flying.zPosition.compareTo(this.lastPosZ) == 0)
{
this.field_72587_r = true;
} else {
this.playerEntity.serverForThisPlayer.sendPacketToPlayer(new Packet11PlayerPosition(this.lastPosX, this.lastPosY + 1.6200000047683716D, this.lastPosY, this.lastPosZ, false));
}
}
if (this.field_72587_r)

@ -0,0 +1,217 @@
package net.minecraft.src;
import java.util.Random;
import static net.minecraft.src.Constants.*;
public class NoiseGeneratorPerlin16 extends NoiseGenerator
{
private int[] permutations;
public double xCoord;
public double yCoord;
public double zCoord;
public NoiseGeneratorPerlin16()
{
this(new Random());
}
public NoiseGeneratorPerlin16(Random par1Random)
{
this.permutations = new int[512];
this.xCoord = par1Random.nextDouble() * 256.0D;
this.yCoord = par1Random.nextDouble() * 256.0D;
this.zCoord = par1Random.nextDouble() * 256.0D;
int var2;
for (var2 = 0; var2 < 256; this.permutations[var2] = var2++)
{
;
}
for (var2 = 0; var2 < 256; ++var2)
{
int var3 = par1Random.nextInt(256 - var2) + var2;
int var4 = this.permutations[var2];
this.permutations[var2] = this.permutations[var3];
this.permutations[var3] = var4;
this.permutations[var2 + 256] = this.permutations[var2];
}
}
public final double lerp(double par1, double par3, double par5)
{
return par3 + par1 * (par5 - par3);
}
public final double grad2d(int par1, double par2, double par4)
{
int var6 = par1 & 15;
double var7 = (double)(1 - ((var6 & 8) >> 3)) * par2;
double var9 = var6 < 4 ? 0.0D : (var6 != 12 && var6 != 14 ? par4 : par2);
return ((var6 & 1) == 0 ? var7 : -var7) + ((var6 & 2) == 0 ? var9 : -var9);
}
public final double grad3d(int par1, double par2, double par4, double par6)
{
int var8 = par1 & 15;
double var9 = var8 < 8 ? par2 : par4;
double var11 = var8 < 4 ? par4 : (var8 != 12 && var8 != 14 ? par6 : par2);
return ((var8 & 1) == 0 ? var9 : -var9) + ((var8 & 2) == 0 ? var11 : -var11);
}
private double floor(double value) {
return MathHelper.clamp_double(value < 0 ? Math.floor(value) + 1 : Math.floor(value), -32768D, 32767D);
}
/**
* pars: noiseArray , xOffset , yOffset , zOffset , xSize , ySize , zSize , xScale, yScale , zScale , noiseScale.
* noiseArray should be xSize*ySize*zSize in size
*/
public void populateNoiseArray(double[] par1ArrayOfDouble, double par2, double par4, double par6, int par8, int par9, int par10, double par11, double par13, double par15, double par17)
{
int var10001;
int var19;
int var22;
double var31;
double var35;
int var37;
double var38;
int var41;
double var42;
int var75;
if (par9 == 1)
{
boolean var64 = false;
boolean var65 = false;
boolean var21 = false;
boolean var68 = false;
double var70 = 0.0D;
double var73 = 0.0D;
var75 = 0;
double var77 = 1.0D / par17;
for (int var30 = 0; var30 < par8; ++var30)
{
var31 = par2 + (double)var30 * par11 + this.xCoord;
double var78 = floor(var31);
if (var31 < (double)var78)
{
--var78;
}
int var34 = (int) (var78 % 256D) & 255;
var31 -= (double)var78;
var35 = var31 * var31 * var31 * (var31 * (var31 * 6.0D - 15.0D) + 10.0D);
for (var37 = 0; var37 < par10; ++var37)
{
var38 = par6 + (double)var37 * par15 + this.zCoord;
double var40 = floor(var38);
if (var38 < (double)var40)
{
--var40;
}
var41 = (int) (var40 % 256D) & 255;
var38 -= (double)var40;
var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D);
var19 = this.permutations[var34] + 0;
int var66 = this.permutations[var19] + var41;
int var67 = this.permutations[var34 + 1] + 0;
var22 = this.permutations[var67] + var41;
var70 = this.lerp(var35, this.grad2d(this.permutations[var66], var31, var38), this.grad3d(this.permutations[var22], var31 - 1.0D, 0.0D, var38));
var73 = this.lerp(var35, this.grad3d(this.permutations[var66 + 1], var31, 0.0D, var38 - 1.0D), this.grad3d(this.permutations[var22 + 1], var31 - 1.0D, 0.0D, var38 - 1.0D));
double var79 = this.lerp(var42, var70, var73);
var10001 = var75++;
par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var79 * var77) : var79 * var77;
}
}
}
else
{
var19 = 0;
double var20 = 1.0D / par17;
var22 = -1;
boolean var23 = false;
boolean var24 = false;
boolean var25 = false;
boolean var26 = false;
boolean var27 = false;
boolean var28 = false;
double var29 = 0.0D;
var31 = 0.0D;
double var33 = 0.0D;
var35 = 0.0D;
for (var37 = 0; var37 < par8; ++var37)
{
var38 = par2 + (double)var37 * par11 + this.xCoord;
double var40 = floor(var38);
if (var38 < (double)var40)
{
--var40;
}
var41 = (int) (var40 % 256D) & 255;
var38 -= (double)var40;
var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D);
for (int var44 = 0; var44 < par10; ++var44)
{
double var45 = par6 + (double)var44 * par15 + this.zCoord;
double var47 = floor(var45);
if (var45 < (double)var47)
{
--var47;
}
int var48 = (int) (var47 % 256D) & 255;
var45 -= (double)var47;
double var49 = var45 * var45 * var45 * (var45 * (var45 * 6.0D - 15.0D) + 10.0D);
for (int var51 = 0; var51 < par9; ++var51)
{
double var52 = par4 + (double)var51 * par13 + this.yCoord;
double var54 = floor(var52);
if (var52 < (double)var54)
{
--var54;
}
int var55 = (int) (var54 % 256D) & 255;
var52 -= (double)var54;
double var56 = var52 * var52 * var52 * (var52 * (var52 * 6.0D - 15.0D) + 10.0D);
if (var51 == 0 || var55 != var22)
{
var22 = var55;
int var69 = this.permutations[var41] + var55;
int var71 = this.permutations[var69] + var48;
int var72 = this.permutations[var69 + 1] + var48;
int var74 = this.permutations[var41 + 1] + var55;
var75 = this.permutations[var74] + var48;
int var76 = this.permutations[var74 + 1] + var48;
var29 = this.lerp(var42, this.grad3d(this.permutations[var71], var38, var52, var45), this.grad3d(this.permutations[var75], var38 - 1.0D, var52, var45));
var31 = this.lerp(var42, this.grad3d(this.permutations[var72], var38, var52 - 1.0D, var45), this.grad3d(this.permutations[var76], var38 - 1.0D, var52 - 1.0D, var45));
var33 = this.lerp(var42, this.grad3d(this.permutations[var71 + 1], var38, var52, var45 - 1.0D), this.grad3d(this.permutations[var75 + 1], var38 - 1.0D, var52, var45 - 1.0D));
var35 = this.lerp(var42, this.grad3d(this.permutations[var72 + 1], var38, var52 - 1.0D, var45 - 1.0D), this.grad3d(this.permutations[var76 + 1], var38 - 1.0D, var52 - 1.0D, var45 - 1.0D));
}
double var58 = this.lerp(var56, var29, var31);
double var60 = this.lerp(var56, var33, var35);
double var62 = this.lerp(var49, var58, var60);
var10001 = var19++;
par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var62 * var20) : var62 * var20;
}
}
}
}
}
}

@ -4,19 +4,19 @@ import java.util.Random;
import static net.minecraft.src.Constants.*;
public class NoiseGeneratorPerlin2 extends NoiseGenerator
public class NoiseGeneratorPerlinDouble extends NoiseGenerator
{
private int[] permutations;
public double xCoord;
public double yCoord;
public double zCoord;
public NoiseGeneratorPerlin2()
public NoiseGeneratorPerlinDouble()
{
this(new Random());
}
public NoiseGeneratorPerlin2(Random par1Random)
public NoiseGeneratorPerlinDouble(Random par1Random)
{
this.permutations = new int[512];
this.xCoord = par1Random.nextDouble() * 256.0D;

@ -0,0 +1,217 @@
package net.minecraft.src;
import java.util.Random;
import static net.minecraft.src.Constants.*;
public class NoiseGeneratorPerlinFloat extends NoiseGenerator
{
private int[] permutations;
public double xCoord;
public double yCoord;
public double zCoord;
public NoiseGeneratorPerlinFloat()
{
this(new Random());
}
public NoiseGeneratorPerlinFloat(Random par1Random)
{
this.permutations = new int[512];
this.xCoord = par1Random.nextDouble() * 256.0D;
this.yCoord = par1Random.nextDouble() * 256.0D;
this.zCoord = par1Random.nextDouble() * 256.0D;
int var2;
for (var2 = 0; var2 < 256; this.permutations[var2] = var2++)
{
;
}
for (var2 = 0; var2 < 256; ++var2)
{
int var3 = par1Random.nextInt(256 - var2) + var2;
int var4 = this.permutations[var2];
this.permutations[var2] = this.permutations[var3];
this.permutations[var3] = var4;
this.permutations[var2 + 256] = this.permutations[var2];
}
}
public final double lerp(double par1, double par3, double par5)
{
return par3 + par1 * (par5 - par3);
}
public final double grad2d(int par1, double par2, double par4)
{
int var6 = par1 & 15;
double var7 = (double)(1 - ((var6 & 8) >> 3)) * par2;
double var9 = var6 < 4 ? 0.0D : (var6 != 12 && var6 != 14 ? par4 : par2);
return ((var6 & 1) == 0 ? var7 : -var7) + ((var6 & 2) == 0 ? var9 : -var9);
}
public final double grad3d(int par1, double par2, double par4, double par6)
{
int var8 = par1 & 15;
double var9 = var8 < 8 ? par2 : par4;
double var11 = var8 < 4 ? par4 : (var8 != 12 && var8 != 14 ? par6 : par2);
return ((var8 & 1) == 0 ? var9 : -var9) + ((var8 & 2) == 0 ? var11 : -var11);
}
private double floor(double value) {
return (float) value < 0 ? Math.floor(value) + 1 : Math.floor(value);
}
/**
* pars: noiseArray , xOffset , yOffset , zOffset , xSize , ySize , zSize , xScale, yScale , zScale , noiseScale.
* noiseArray should be xSize*ySize*zSize in size
*/
public void populateNoiseArray(double[] par1ArrayOfDouble, double par2, double par4, double par6, int par8, int par9, int par10, double par11, double par13, double par15, double par17)
{
int var10001;
int var19;
int var22;
double var31;
double var35;
int var37;
double var38;
int var41;
double var42;
int var75;
if (par9 == 1)
{
boolean var64 = false;
boolean var65 = false;
boolean var21 = false;
boolean var68 = false;
double var70 = 0.0D;
double var73 = 0.0D;
var75 = 0;
double var77 = 1.0D / par17;
for (int var30 = 0; var30 < par8; ++var30)
{
var31 = par2 + (double)var30 * par11 + this.xCoord;
double var78 = floor(var31);
if (var31 < (double)var78)
{
--var78;
}
int var34 = (int) (var78 % 256D) & 255;
var31 -= (double)var78;
var35 = var31 * var31 * var31 * (var31 * (var31 * 6.0D - 15.0D) + 10.0D);
for (var37 = 0; var37 < par10; ++var37)
{
var38 = par6 + (double)var37 * par15 + this.zCoord;
double var40 = floor(var38);
if (var38 < (double)var40)
{
--var40;
}
var41 = (int) (var40 % 256D) & 255;
var38 -= (double)var40;
var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D);
var19 = this.permutations[var34] + 0;
int var66 = this.permutations[var19] + var41;
int var67 = this.permutations[var34 + 1] + 0;
var22 = this.permutations[var67] + var41;
var70 = this.lerp(var35, this.grad2d(this.permutations[var66], var31, var38), this.grad3d(this.permutations[var22], var31 - 1.0D, 0.0D, var38));
var73 = this.lerp(var35, this.grad3d(this.permutations[var66 + 1], var31, 0.0D, var38 - 1.0D), this.grad3d(this.permutations[var22 + 1], var31 - 1.0D, 0.0D, var38 - 1.0D));
double var79 = this.lerp(var42, var70, var73);
var10001 = var75++;
par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var79 * var77) : var79 * var77;
}
}
}
else
{
var19 = 0;
double var20 = 1.0D / par17;
var22 = -1;
boolean var23 = false;
boolean var24 = false;
boolean var25 = false;
boolean var26 = false;
boolean var27 = false;
boolean var28 = false;
double var29 = 0.0D;
var31 = 0.0D;
double var33 = 0.0D;
var35 = 0.0D;
for (var37 = 0; var37 < par8; ++var37)
{
var38 = par2 + (double)var37 * par11 + this.xCoord;
double var40 = floor(var38);
if (var38 < (double)var40)
{
--var40;
}
var41 = (int) (var40 % 256D) & 255;
var38 -= (double)var40;
var42 = var38 * var38 * var38 * (var38 * (var38 * 6.0D - 15.0D) + 10.0D);
for (int var44 = 0; var44 < par10; ++var44)
{
double var45 = par6 + (double)var44 * par15 + this.zCoord;
double var47 = floor(var45);
if (var45 < (double)var47)
{
--var47;
}
int var48 = (int) (var47 % 256D) & 255;
var45 -= (double)var47;
double var49 = var45 * var45 * var45 * (var45 * (var45 * 6.0D - 15.0D) + 10.0D);
for (int var51 = 0; var51 < par9; ++var51)
{
double var52 = par4 + (double)var51 * par13 + this.yCoord;
double var54 = floor(var52);
if (var52 < (double)var54)
{
--var54;
}
int var55 = (int) (var54 % 256D) & 255;
var52 -= (double)var54;
double var56 = var52 * var52 * var52 * (var52 * (var52 * 6.0D - 15.0D) + 10.0D);
if (var51 == 0 || var55 != var22)
{
var22 = var55;
int var69 = this.permutations[var41] + var55;
int var71 = this.permutations[var69] + var48;
int var72 = this.permutations[var69 + 1] + var48;
int var74 = this.permutations[var41 + 1] + var55;
var75 = this.permutations[var74] + var48;
int var76 = this.permutations[var74 + 1] + var48;
var29 = this.lerp(var42, this.grad3d(this.permutations[var71], var38, var52, var45), this.grad3d(this.permutations[var75], var38 - 1.0D, var52, var45));
var31 = this.lerp(var42, this.grad3d(this.permutations[var72], var38, var52 - 1.0D, var45), this.grad3d(this.permutations[var76], var38 - 1.0D, var52 - 1.0D, var45));
var33 = this.lerp(var42, this.grad3d(this.permutations[var71 + 1], var38, var52, var45 - 1.0D), this.grad3d(this.permutations[var75 + 1], var38 - 1.0D, var52, var45 - 1.0D));
var35 = this.lerp(var42, this.grad3d(this.permutations[var72 + 1], var38, var52 - 1.0D, var45 - 1.0D), this.grad3d(this.permutations[var76 + 1], var38 - 1.0D, var52 - 1.0D, var45 - 1.0D));
}
double var58 = this.lerp(var56, var29, var31);
double var60 = this.lerp(var56, var33, var35);
double var62 = this.lerp(var49, var58, var60);
var10001 = var19++;
par1ArrayOfDouble[var10001] += FLOAT_PERLIN_GENERATOR ? (float) (var62 * var20) : var62 * var20;
}
}
}
}
}
}

@ -49,10 +49,12 @@ public class OpenGlHelper
{
if (useMultitextureARB)
{
ARBMultitexture.glClientActiveTextureARB(par0);
ARBMultitexture.glActiveTextureARB(par0);
}
else
{
GL13.glClientActiveTexture(par0);
GL13.glActiveTexture(par0);
}
}

@ -3,6 +3,12 @@ package net.minecraft.src;
import java.util.Random;
public enum PerlinNoiseFactory {
shortType {
@Override
public NoiseGenerator createPerlinNoiseGenerator(Random random) {
return new NoiseGeneratorPerlin16(random);
}
},
intType {
@Override
public NoiseGenerator createPerlinNoiseGenerator(Random random) {
@ -15,10 +21,16 @@ public enum PerlinNoiseFactory {
return new NoiseGeneratorPerlin64(random);
}
},
floatType {
@Override
public NoiseGenerator createPerlinNoiseGenerator(Random random) {
return new NoiseGeneratorPerlinFloat(random);
}
},
doubleType {
@Override
public NoiseGenerator createPerlinNoiseGenerator(Random random) {
return new NoiseGeneratorPerlin2(random);
return new NoiseGeneratorPerlinDouble(random);
}
};

Loading…
Cancel
Save