Compare commits

..

11 Commits
master ... test

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

@ -223,7 +223,7 @@ public class AnvilChunkLoader implements IThreadedFileIO, IChunkLoader
if (var9 != null)
{
var10 = new NBTTagCompound();
var10.setByte("Y", (byte)(var9.getYLocation() >> 4 & 255));
var10.setByte("Y", (byte)(var9.getYLocation() & 255));
var10.setByteArray("Blocks", var9.getBlockLSBArray());
if (var9.getBlockMSBArray() != null)
@ -313,11 +313,11 @@ public class AnvilChunkLoader implements IThreadedFileIO, IChunkLoader
byte var7 = 16;
ExtendedBlockStorage[] var8 = new ExtendedBlockStorage[var7];
for (int var9 = 0; var9 < var6.tagCount(); ++var9)
for (int var9 = 0; var9 < var6.tagCount() && var9 < var8.length; ++var9)
{
NBTTagCompound var10 = (NBTTagCompound)var6.tagAt(var9);
byte var11 = var10.getByte("Y");
ExtendedBlockStorage var12 = new ExtendedBlockStorage(var11 << 4);
ExtendedBlockStorage var12 = new ExtendedBlockStorage(var11);
var12.setBlockLSBArray(var10.getByteArray("Blocks"));
if (var10.hasKey("Add"))

@ -5,6 +5,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Random;
@ -21,6 +22,8 @@ public class Chunk
* logical segment of 16x16x16 blocks, stacked vertically.
*/
private ExtendedBlockStorage[] storageArrays;
private LinkedList<ExtendedBlockStorage>[] extraStorageArray = new LinkedList[256];
/**
* Contains a 16x16 mapping on the X/Z plane of the biome ID to which each colum belongs.
@ -127,12 +130,7 @@ public class Chunk
{
int var10 = var8 >> 4;
if (this.storageArrays[var10] == null)
{
this.storageArrays[var10] = new ExtendedBlockStorage(var10 << 4);
}
this.storageArrays[var10].setExtBlockID(var6, var8 & 15, var7, var9);
getBlockStorage(var10).setExtBlockID(var6, var8 & 15, var7, var9);
}
}
}
@ -178,7 +176,22 @@ public class Chunk
{
return this.storageArrays;
}
public ExtendedBlockStorage getBlockStorage(int yBase) {
if(yBase < 0 || yBase >= storageArrays.length) {
LinkedList<ExtendedBlockStorage> list = extraStorageArray[yBase & 0xFF];
if(list == null) list = extraStorageArray[yBase & 0xFF] = new LinkedList<>();
for(ExtendedBlockStorage blockStorage : list) if(blockStorage.yBase == yBase) return blockStorage;
ExtendedBlockStorage blockStorage = new ExtendedBlockStorage(yBase);
list.add(blockStorage);
worldObj.addExtraChunk(xPosition, yBase, zPosition, blockStorage);
return blockStorage;
} else {
ExtendedBlockStorage blockStorage;
return (blockStorage = storageArrays[yBase]) == null ? storageArrays[yBase] = new ExtendedBlockStorage(yBase) : blockStorage;
}
}
/**
* Generates the height map for a chunk from scratch
*/
@ -510,15 +523,8 @@ public class Chunk
*/
public int getBlockID(int par1, int par2, int par3)
{
if (par2 >> 4 >= this.storageArrays.length)
{
return 0;
}
else
{
ExtendedBlockStorage var4 = this.storageArrays[par2 >> 4];
return var4 != null ? var4.getExtBlockID(par1, par2 & 15, par3) : 0;
}
ExtendedBlockStorage var4 = this.getBlockStorage(par2 >> 4);
return var4 != null ? var4.getExtBlockID(par1, par2 & 15, par3) : 0;
}
/**
@ -526,15 +532,8 @@ public class Chunk
*/
public int getBlockMetadata(int par1, int par2, int par3)
{
if (par2 >> 4 >= this.storageArrays.length)
{
return 0;
}
else
{
ExtendedBlockStorage var4 = this.storageArrays[par2 >> 4];
return var4 != null ? var4.getExtBlockMetadata(par1, par2 & 15, par3) : 0;
}
ExtendedBlockStorage var4 = this.getBlockStorage(par2 >> 4);
return var4 != null ? var4.getExtBlockMetadata(par1, par2 & 15, par3) : 0;
}
/**
@ -567,7 +566,7 @@ public class Chunk
}
else
{
ExtendedBlockStorage var10 = this.storageArrays[par2 >> 4];
ExtendedBlockStorage var10 = this.getBlockStorage(par2 >> 4);
boolean var11 = false;
if (var10 == null)
@ -678,7 +677,7 @@ public class Chunk
*/
public boolean setBlockMetadata(int par1, int par2, int par3, int par4)
{
ExtendedBlockStorage var5 = this.storageArrays[par2 >> 4];
ExtendedBlockStorage var5 = this.getBlockStorage(par2 >> 4);
if (var5 == null)
{
@ -719,7 +718,7 @@ public class Chunk
*/
public int getSavedLightValue(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4)
{
ExtendedBlockStorage var5 = this.storageArrays[par3 >> 4];
ExtendedBlockStorage var5 = this.getBlockStorage(par3 >> 4);
return var5 == null ? (this.canBlockSeeTheSky(par2, par3, par4) ? par1EnumSkyBlock.defaultLightValue : 0) : (par1EnumSkyBlock == EnumSkyBlock.Sky ? var5.getExtSkylightValue(par2, par3 & 15, par4) : (par1EnumSkyBlock == EnumSkyBlock.Block ? var5.getExtBlocklightValue(par2, par3 & 15, par4) : par1EnumSkyBlock.defaultLightValue));
}
@ -729,7 +728,7 @@ public class Chunk
*/
public void setLightValue(EnumSkyBlock par1EnumSkyBlock, int par2, int par3, int par4, int par5)
{
ExtendedBlockStorage var6 = this.storageArrays[par3 >> 4];
ExtendedBlockStorage var6 = this.getBlockStorage(par3 >> 4);
if (var6 == null)
{
@ -757,7 +756,7 @@ public class Chunk
*/
public int getBlockLightValue(int par1, int par2, int par3, int par4)
{
ExtendedBlockStorage var5 = this.storageArrays[par2 >> 4];
ExtendedBlockStorage var5 = this.getBlockStorage(par2 >> 4);
if (var5 == null)
{
@ -1197,19 +1196,9 @@ public class Chunk
*/
public boolean getAreLevelsEmpty(int par1, int par2)
{
if (par1 < 0)
{
par1 = 0;
}
if (par2 >= 256)
{
par2 = 255;
}
for (int var3 = par1; var3 <= par2; var3 += 16)
{
ExtendedBlockStorage var4 = this.storageArrays[var3 >> 4];
ExtendedBlockStorage var4 = this.getBlockStorage(var3 >> 4);
if (var4 != null && !var4.isEmpty())
{
@ -1441,4 +1430,8 @@ public class Chunk
// }
// }
}
public LinkedList<ExtendedBlockStorage>[] getExtraStorageArray() {
return extraStorageArray;
}
}

@ -57,28 +57,17 @@ public class ChunkCache implements IBlockAccess
*/
public int getBlockId(BigInteger par1, int par2, BigInteger par3)
{
if (par2 < 0)
{
return 0;
}
else if (par2 >= 256)
int var4 = (par1.shiftRight(4)).subtract(chunkX).intValueExact();
int var5 = (par3.shiftRight(4)).subtract(chunkZ).intValueExact();
if (var4 >= 0 && var4 < this.chunkArray.length && var5 >= 0 && var5 < this.chunkArray[var4].length)
{
return 0;
Chunk var6 = this.chunkArray[var4][var5];
return var6 == null ? 0 : var6.getBlockID(par1.intValue() & 15, par2, par3.intValue() & 15);
}
else
{
int var4 = (par1.shiftRight(4)).subtract(chunkX).intValueExact();
int var5 = (par3.shiftRight(4)).subtract(chunkZ).intValueExact();
if (var4 >= 0 && var4 < this.chunkArray.length && var5 >= 0 && var5 < this.chunkArray[var4].length)
{
Chunk var6 = this.chunkArray[var4][var5];
return var6 == null ? 0 : var6.getBlockID(par1.intValue() & 15, par2, par3.intValue() & 15);
}
else
{
return 0;
}
return 0;
}
}
@ -209,20 +198,9 @@ public class ChunkCache implements IBlockAccess
*/
public int getBlockMetadata(BigInteger par1, int par2, BigInteger par3)
{
if (par2 < 0)
{
return 0;
}
else if (par2 >= 256)
{
return 0;
}
else
{
int var4 = (par1.shiftRight(4)).subtract(chunkX).intValueExact();
int var5 = (par3.shiftRight(4)).subtract(chunkZ).intValueExact();
return this.chunkArray[var4][var5].getBlockMetadata(par1.intValue() & 15, par2, par3.intValue() & 15);
}
int var4 = (par1.shiftRight(4)).subtract(chunkX).intValueExact();
int var5 = (par3.shiftRight(4)).subtract(chunkZ).intValueExact();
return this.chunkArray[var4][var5].getBlockMetadata(par1.intValue() & 15, par2, par3.intValue() & 15);
}
/**

@ -98,83 +98,80 @@ public class ChunkProviderGenerate implements IChunkProvider
*/
public void generateTerrain(BigInteger par1, BigInteger par2, byte[] par3ArrayOfByte)
{
byte width1 = 4;
byte height1 = 16;
byte seaLevel = 63;
// int var7 = width1 + 1;
byte noiseHeight = 17;
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);
// Scan blocks...
for (int x1 = 0; x1 < width1; ++x1)
byte var4 = 4;
byte var5 = 16;
byte var6 = 63;
int var7 = var4 + 1;
byte var8 = 17;
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);
for (int var10 = 0; var10 < var4; ++var10)
{
for (int z1 = 0; z1 < width1; ++z1)
for (int var11 = 0; var11 < var4; ++var11)
{
for (int y1 = 0; y1 < height1; ++y1)
for (int var12 = 0; var12 < var5; ++var12)
{
// 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 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)
{
double step4 = 0.25D;
double EE = AA;
double FF = BB;
double stepEE = (CC - AA) * step4;
double stepFF = (DD - BB) * step4;
double var32 = 0.25D;
double var34 = var15;
double var36 = var17;
double var38 = (var19 - var15) * var32;
double var40 = (var21 - var17) * var32;
for (int x2 = 0; x2 < 4; ++x2)
for (int var42 = 0; var42 < 4; ++var42)
{
int xzy = x2 + x1 * 4 << 11 | 0 + z1 * 4 << 7 | y1 * 8 + y2;
short height = 128;
xzy -= height;
// double var45 = 0.25D;
double stepGG = (FF - EE) * step4;
double GG = EE - stepGG;
for (int z2 = 0; z2 < 4; ++z2)
int var43 = var42 + var10 * 4 << 11 | 0 + var11 * 4 << 7 | var12 * 8 + var31;
short var44 = 128;
var43 -= var44;
double var45 = 0.25D;
double var49 = (var36 - var34) * var45;
double var47 = var34 - var49;
for (int var51 = 0; var51 < 4; ++var51)
{
if(!ENABLE_FRINGE_LAND) {
GG += stepGG;
var47 += var49;
} else {
if(z2 == 0) GG = EE;
if(var51 == 0) var47 = var34;
}
if (GG > 0.0D)
if (var47 > 0.0D)
{
par3ArrayOfByte[xzy += height] = (byte)Block.stone.blockID;
par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID;
}
else if (y1 * 8 + y2 < seaLevel)
else if (var12 * 8 + var31 < var6)
{
par3ArrayOfByte[xzy += height] = (byte)Block.waterStill.blockID;
par3ArrayOfByte[var43 += var44] = (byte)Block.waterStill.blockID;
}
else
{
par3ArrayOfByte[xzy += height] = 0;
par3ArrayOfByte[var43 += var44] = 0;
}
if(ENABLE_FRINGE_LAND) {
GG += stepGG;
var47 += var49;
}
}
EE += stepEE;
FF += stepFF;
var34 += var38;
var36 += var40;
}
AA += stepAA;
BB += stepBB;
CC += stepCC;
DD += stepDD;
var15 += var23;
var17 += var25;
var19 += var27;
var21 += var29;
}
}
}
@ -204,15 +201,15 @@ public class ChunkProviderGenerate implements IChunkProvider
for (int var16 = 127; var16 >= 0; --var16)
{
int xzy = (var9 * 16 + var8) * 128 + var16;
int var17 = (var9 * 16 + var8) * 128 + var16;
if (var16 <= 0 + this.rand.nextInt(5))
{
par3ArrayOfByte[xzy] = (byte)Block.bedrock.blockID;
// par3ArrayOfByte[var17] = (byte)Block.bedrock.blockID;
}
else
{
byte var18 = par3ArrayOfByte[xzy];
byte var18 = par3ArrayOfByte[var17];
if (var18 == 0)
{
@ -249,17 +246,17 @@ public class ChunkProviderGenerate implements IChunkProvider
if (var16 >= var5 - 1)
{
par3ArrayOfByte[xzy] = var14;
par3ArrayOfByte[var17] = var14;
}
else
{
par3ArrayOfByte[xzy] = var15;
par3ArrayOfByte[var17] = var15;
}
}
else if (var13 > 0)
{
--var13;
par3ArrayOfByte[xzy] = var15;
par3ArrayOfByte[var17] = var15;
if (var13 == 0 && var15 == Block.sand.blockID)
{
@ -320,11 +317,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[] noiseTable, BigInteger x, int y, BigInteger z, int width, int depth, int height)
private double[] initializeNoiseField(double[] par1ArrayOfDouble, BigInteger par2, int par3, BigInteger par4, int par5, int par6, int par7)
{
if (noiseTable == null)
if (par1ArrayOfDouble == null)
{
noiseTable = new double[width * depth * height];
par1ArrayOfDouble = new double[par5 * par6 * par7];
}
if (this.parabolicField == null)
@ -341,33 +338,33 @@ public class ChunkProviderGenerate implements IChunkProvider
}
}
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);
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);
boolean var43 = false;
boolean var42 = false;
int var12 = 0;
int var13 = 0;
for (int var14 = 0; var14 < width; ++var14)
for (int var14 = 0; var14 < par5; ++var14)
{
for (int var15 = 0; var15 < height; ++var15)
for (int var15 = 0; var15 < par7; ++var15)
{
float maxHeight = 0.0F;
float minHeight = 0.0F;
float var16 = 0.0F;
float var17 = 0.0F;
float var18 = 0.0F;
byte var19 = 2;
BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (width + 5)];
BiomeGenBase var20 = this.biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 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) * (width + 5)];
BiomeGenBase var23 = this.biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)];
float var24 = this.parabolicField[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F);
if (var23.minHeight > var20.minHeight)
@ -375,16 +372,16 @@ public class ChunkProviderGenerate implements IChunkProvider
var24 /= 2.0F;
}
maxHeight += var23.maxHeight * var24;
minHeight += var23.minHeight * var24;
var16 += var23.maxHeight * var24;
var17 += var23.minHeight * var24;
var18 += var24;
}
}
maxHeight /= var18;
minHeight /= var18;
maxHeight = maxHeight * 0.9F + 0.1F;
minHeight = (minHeight * 4.0F - 1.0F) / 8.0F;
var16 /= var18;
var17 /= var18;
var16 = var16 * 0.9F + 0.1F;
var17 = (var17 * 4.0F - 1.0F) / 8.0F;
double var46 = this.noise6[var13] / 8000.0D;
if (var46 < 0.0D)
@ -418,13 +415,13 @@ public class ChunkProviderGenerate implements IChunkProvider
++var13;
for (int var47 = 0; var47 < depth; ++var47)
for (int var47 = 0; var47 < par6; ++var47)
{
double var48 = (double)minHeight;
double var26 = (double)maxHeight;
double var48 = (double)var17;
double var26 = (double)var16;
var48 += var46 * 0.2D;
var48 = var48 * (double)depth / 16.0D;
double var28 = (double)depth / 2.0D + var48 * 4.0D;
var48 = var48 * (double)par6 / 16.0D;
double var28 = (double)par6 / 2.0D + var48 * 4.0D;
double var30 = 0.0D;
double var32 = ((double)var47 - var28) * 12.0D * 128.0D / 128.0D / var26;
@ -452,19 +449,105 @@ public class ChunkProviderGenerate implements IChunkProvider
var30 -= var32;
if (var47 > depth - 4)
if (var47 > par6 - 4)
{
double var40 = (double)((float)(var47 - (depth - 4)) / 3.0F);
double var40 = (double)((float)(var47 - (par6 - 4)) / 3.0F);
var30 = var30 * (1.0D - var40) + -10.0D * var40;
}
noiseTable[var12] = var30;
par1ArrayOfDouble[var12] = var30 - par3;
++var12;
}
}
}
return noiseTable;
return par1ArrayOfDouble;
}
// FIXME
public void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
byte var4 = 4;
byte var5 = 2;
int var7 = var4 + 1;
byte var8 = 3;
int var9 = var4 + 1;
byte[] par3ArrayOfByte = new byte[1 << 12];
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, x.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), z.multiply(BigInteger.valueOf(4)).subtract(BigInteger.valueOf(2)), var7 + 5, var9 + 5);
double[] noiseArray = initializeNoiseField(null, x.multiply(BigInteger.valueOf(var4)), y * var4, z.multiply(BigInteger.valueOf(var4)), var7, var8, var9);
for (int var10 = 0; var10 < var4; ++var10)
{
for (int var11 = 0; var11 < var4; ++var11)
{
for (int var12 = 0; var12 < var5; ++var12)
{
double var13 = 0.125D;
double var15 = noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 0];
double var17 = noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 0];
double var19 = noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 0];
double var21 = noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 0];
double var23 = (noiseArray[((var10 + 0) * var9 + var11 + 0) * var8 + var12 + 1] - var15) * var13;
double var25 = (noiseArray[((var10 + 0) * var9 + var11 + 1) * var8 + var12 + 1] - var17) * var13;
double var27 = (noiseArray[((var10 + 1) * var9 + var11 + 0) * var8 + var12 + 1] - var19) * var13;
double var29 = (noiseArray[((var10 + 1) * var9 + var11 + 1) * var8 + var12 + 1] - var21) * var13;
var15 += var23 * Math.floorDiv(y, 16);
var17 += var25 * Math.floorDiv(y, 16);
var19 += var27 * Math.floorDiv(y, 16);
var21 += var29 * Math.floorDiv(y, 16);
for (int var31 = 0; var31 < 8; ++var31)
{
double var32 = 0.25D;
double var34 = var15;
double var36 = var17;
double var38 = (var19 - var15) * var32;
double var40 = (var21 - var17) * var32;
for (int var42 = 0; var42 < 4; ++var42)
{
int var43 = var42 + var10 * 4 << 8 | 0 + var11 * 4 << 4 | var12 * 8 + var31;
short var44 = 16;
var43 -= var44;
double var45 = 0.25D;
double var49 = (var36 - var34) * var45;
double var47 = var34 - var49;
for (int var51 = 0; var51 < 4; ++var51)
{
if(!ENABLE_FRINGE_LAND) {
var47 += var49;
} else {
if(var51 == 0) var47 = var34;
}
if (var47 > 0.0D)
{
par3ArrayOfByte[var43 += var44] = (byte)Block.stone.blockID;
}
else
{
par3ArrayOfByte[var43 += var44] = 0;
}
if(ENABLE_FRINGE_LAND) {
var47 += var49;
}
}
var34 += var38;
var36 += var40;
}
var15 += var23;
var17 += var25;
var19 += var27;
var21 += var29;
}
}
}
}
for(int i = 0; i < 16; i++) for(int j = 0; j < 16; j++) for(int k = 0; k < 16; k++) {
int blockId = par3ArrayOfByte[i << 8 | k << 4 | j] & 0xFF;
if(blockId != 0) storage.setExtBlockID(i, j, k, blockId);
}
}
/**

@ -333,4 +333,8 @@ public class ChunkProviderServer implements IChunkProvider
{
return this.loadedChunkHashMap.size();
}
public void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
this.currentChunkProvider.generateExtraBlockStorage(x, y, z, storage);
}
}

@ -63,7 +63,7 @@ public class CommandServerTp extends CommandBase
int var5 = par2ArrayOfStr.length - 3;
int var6 = 30000000;
BigDecimal var7 = parseBigDecimal(par1ICommandSender, par2ArrayOfStr[var5++]);
int var8 = parseIntBounded(par1ICommandSender, par2ArrayOfStr[var5++], 0, 256);
int var8 = parseInt(par1ICommandSender, par2ArrayOfStr[var5++]);
BigDecimal var9 = parseBigDecimal(par1ICommandSender, par2ArrayOfStr[var5++]);
var4.serverForThisPlayer.setPlayerLocation(var7.add(BigDecimal.valueOf(0.5)), (double)var8, var9.add(BigDecimal.valueOf(0.5)), var4.rotationYaw, var4.rotationPitch);
notifyAdmins(par1ICommandSender, "commands.tp.coordinates", new Object[] {var4.getEntityName(), var7.toString(), Integer.valueOf(var8), var9.toString()});

@ -7,8 +7,7 @@ public class Constants {
public static boolean DISABLE_MODULO = false,
ENABLE_FRINGE_LAND = false,
FLOAT_PERLIN_GENERATOR = false,
COMPILE_CHUNK_ASYNC = false,
DISABLE_ENTITY_UPDATE = false;
COMPILE_CHUNK_ASYNC = false;
@Deprecated(/* forRemoval = true */)
public static boolean USE_64BIT_PERLIN_GENERATOR = false;
@ -26,12 +25,12 @@ public class Constants {
try {
for(Field f : cls.getDeclaredFields()) {
// unsafe.putBoolean(cls, unsafe.fieldOffset(f), Boolean.getBoolean(cls.getName() + "." + f.getName()));
f.setBoolean(null, Boolean.getBoolean("net.minecraft.src.Constants." + f.getName()));
f.setBoolean(null, Boolean.getBoolean(cls.getName() + "." + f.getName()));
}
} catch(Throwable t) {
throw new RuntimeException(t);
}
if(System.getProperty("net.minecraft.src.Constants.USE_64BIT_PERLIN_GENERATOR") != null) {
if(System.getProperty(cls.getName() + ".USE_64BIT_PERLIN_GENERATOR") != null) {
System.err.println("USE_64BIT_PERLIN_GENERATOR is deprecated and will remove in future, Please consider use -Dnet.minecraft.src.NoiseGeneratorOctaves.noiseType=" + (USE_64BIT_PERLIN_GENERATOR ? "long" : "int") + "Type");
}
}

@ -467,10 +467,10 @@ public abstract class Entity
this.fallDistance *= 0.5F;
}
if (this.posY < -64.0D)
{
this.kill();
}
// if (this.posY < -64.0D)
// {
// this.kill();
// }
if (!this.worldObj.isRemote)
{

@ -173,7 +173,7 @@ public class EntityPlayerMP extends EntityPlayer implements ICrafting
if (!this.chunksToLoad.isEmpty())
{
ArrayList var6 = new ArrayList();
ArrayList<Chunk> var6 = new ArrayList<>();
Iterator var7 = this.chunksToLoad.iterator();
ArrayList var3 = new ArrayList();
@ -192,6 +192,16 @@ public class EntityPlayerMP extends EntityPlayer implements ICrafting
if (!var6.isEmpty())
{
this.serverForThisPlayer.sendPacketToPlayer(new Packet56MapChunks(var6));
for(Chunk chunk : var6) {
LinkedList<ExtendedBlockStorage>[] list = chunk.getExtraStorageArray();
for (int i = 0; i < list.length; i++) {
LinkedList<ExtendedBlockStorage> linkedList = list[i];
if(linkedList == null) continue;
for(ExtendedBlockStorage blockStorage : linkedList) {
this.serverForThisPlayer.sendPacketToPlayer(new Packet57ExtraChunk(chunk.xPosition, blockStorage.yBase, chunk.zPosition, blockStorage));
}
}
}
Iterator var10 = var3.iterator();
while (var10.hasNext())

@ -994,7 +994,9 @@ public class EntityRenderer
this.mc.mcProfiler.endStartSection("culling");
Frustrum var14 = new Frustrum();
var14.setPosition(var7, var9, var11);
// long time = System.currentTimeMillis();
this.mc.renderGlobal.clipRenderersByFrustum(var14, par1);
// System.out.println(System.currentTimeMillis() - time);
if (var13 == 0)
{

@ -5,7 +5,7 @@ public class ExtendedBlockStorage
/**
* Contains the bottom-most Y block represented by this ExtendedBlockStorage. Typically a multiple of 16.
*/
private int yBase;
int yBase;
/**
* A total count of the number of non-air blocks in this block storage's Chunk.
@ -46,6 +46,7 @@ public class ExtendedBlockStorage
this.blockMetadataArray = new NibbleArray(this.blockLSBArray.length, 4);
this.skylightArray = new NibbleArray(this.blockLSBArray.length, 4);
this.blocklightArray = new NibbleArray(this.blockLSBArray.length, 4);
this.blockMSBArray = new NibbleArray(this.blockLSBArray.length, 4);
}
/**
@ -316,4 +317,12 @@ public class ExtendedBlockStorage
this.blockMSBArray = new NibbleArray(this.blockLSBArray.length, 4);
return this.blockMSBArray;
}
public int getBlockRefCnt() {
return this.blockRefCount;
}
public void setBlockRefCnt(int blockRefCnt) {
this.blockRefCount = blockRefCnt;
}
}

@ -59,4 +59,6 @@ public interface IChunkProvider
ChunkPosition findClosestStructure(World var1, String var2, BigInteger var3, int var4, BigInteger var5);
int getLoadedChunkCount();
default void generateExtraBlockStorage(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {}
}

@ -72,10 +72,10 @@ public class ItemBlock extends Item
{
return false;
}
else if (par5 == 255 && Block.blocksList[this.blockID].blockMaterial.isSolid())
/*else if (par5 == 255 && Block.blocksList[this.blockID].blockMaterial.isSolid())
{
return false;
}
}*/
else if (par3World.canPlaceEntityOnSide(this.blockID, par4, par5, par6, false, par7, par2EntityPlayer))
{
Block var12 = Block.blocksList[this.blockID];

@ -141,11 +141,6 @@ 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.

@ -581,6 +581,19 @@ public class NetClientHandler extends NetHandler
{
this.worldClient.setBlockAndMetadataAndInvalidate(par1Packet53BlockChange.xPosition, par1Packet53BlockChange.yPosition, par1Packet53BlockChange.zPosition, par1Packet53BlockChange.type, par1Packet53BlockChange.metadata);
}
public void handleAddExtraChunk(Packet57ExtraChunk packet) {
Chunk chunk = this.worldClient.getChunkFromChunkCoords(packet.getX(), packet.getZ());
if(chunk instanceof EmptyChunk) throw new RuntimeException("Attempt send extra chunk data on empty chunk!");
ExtendedBlockStorage storage = chunk.getBlockStorage(packet.getY());
System.arraycopy(packet.getBlockLSB() , 0, storage.getBlockLSBArray() , 0, storage.getBlockLSBArray() .length);
System.arraycopy(packet.getBlockMSB() , 0, storage.getBlockMSBArray() .data, 0, storage.getBlockMSBArray() .data.length);
System.arraycopy(packet.getMetadata() , 0, storage.getMetadataArray() .data, 0, storage.getMetadataArray() .data.length);
System.arraycopy(packet.getSkyLight() , 0, storage.getSkylightArray() .data, 0, storage.getSkylightArray() .data.length);
System.arraycopy(packet.getBlockLight(), 0, storage.getBlocklightArray().data, 0, storage.getBlocklightArray().data.length);
storage.setBlockRefCnt(packet.getBlockRefCnt());
this.worldClient.markBlocksDirty(packet.getX().shiftLeft(4), packet.getY() << 4, packet.getZ().shiftLeft(4), (packet.getX().shiftLeft(4)).add(BigInteger.valueOf(16)), (packet.getY() << 4) + 16, (packet.getZ().shiftLeft(4)).add(BigInteger.valueOf(16)));
}
public void handleKickDisconnect(Packet255KickDisconnect par1Packet255KickDisconnect)
{

@ -409,6 +409,10 @@ public abstract class NetHandler
{
this.registerPacket(par1Packet56MapChunks);
}
public void handleAddExtraChunk(Packet57ExtraChunk packet57ExtraChunks) {
registerPacket(packet57ExtraChunks);
}
/**
* packet.processPacket is only called if this returns true
@ -417,4 +421,5 @@ public abstract class NetHandler
{
return false;
}
}

@ -128,14 +128,13 @@ 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;
} else {
this.playerEntity.serverForThisPlayer.sendPacketToPlayer(new Packet11PlayerPosition(this.lastPosX, this.lastPosY + 1.6200000047683716D, this.lastPosY, this.lastPosZ, false));
}
// 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;
}
if (this.field_72587_r)
@ -400,10 +399,10 @@ public class NetServerHandler extends NetHandler
return;
}
if (var6 >= this.mcServer.getBuildLimit())
{
return;
}
// if (var6 >= this.mcServer.getBuildLimit())
// {
// return;
// }
}
ChunkCoordinates var19 = var2.getSpawnPoint();
@ -481,11 +480,11 @@ public class NetServerHandler extends NetHandler
this.playerEntity.theItemInWorldManager.tryUseItem(this.playerEntity, var2, var3);
}
else if (par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit() - 1 && (par1Packet15Place.getDirection() == 1 || par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit()))
/*else if (par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit() - 1 && (par1Packet15Place.getDirection() == 1 || par1Packet15Place.getYPosition() >= this.mcServer.getBuildLimit()))
{
this.playerEntity.serverForThisPlayer.sendPacketToPlayer(new Packet3Chat("\u00a77Height limit for building is " + this.mcServer.getBuildLimit()));
var4 = true;
}
}*/
else
{
ChunkCoordinates var10 = var2.getSpawnPoint();

@ -3,8 +3,6 @@ package net.minecraft.src;
public abstract class NoiseGenerator
{
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) {
if (this instanceof NoiseGeneratorPerlin) {
((NoiseGeneratorPerlin) this).populateNoiseArray(par1ArrayOfDouble, par2, par4, par6, par8, par9, par10, par11, par13, par15, par17);
} else throw new Error("Fucked by MCP™");
}
}

@ -33,7 +33,7 @@ public class NoiseGeneratorOctaves extends NoiseGenerator
*/
public double[] generateNoiseOctaves(double[] par1ArrayOfDouble, BigInteger par2, BigInteger par3, BigInteger par4, int par5, int par6, int par7, double par8, double par10, double par12)
{
if (par1ArrayOfDouble == null)
if (par1ArrayOfDouble == null || par1ArrayOfDouble.length < par5 * par6 * par7)
{
par1ArrayOfDouble = new double[par5 * par6 * par7];
}

@ -1,217 +0,0 @@
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 NoiseGeneratorPerlinDouble extends NoiseGenerator
public class NoiseGeneratorPerlin2 extends NoiseGenerator
{
private int[] permutations;
public double xCoord;
public double yCoord;
public double zCoord;
public NoiseGeneratorPerlinDouble()
public NoiseGeneratorPerlin2()
{
this(new Random());
}
public NoiseGeneratorPerlinDouble(Random par1Random)
public NoiseGeneratorPerlin2(Random par1Random)
{
this.permutations = new int[512];
this.xCoord = par1Random.nextDouble() * 256.0D;

@ -1,217 +0,0 @@
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,12 +49,10 @@ public class OpenGlHelper
{
if (useMultitextureARB)
{
ARBMultitexture.glClientActiveTextureARB(par0);
ARBMultitexture.glActiveTextureARB(par0);
}
else
{
GL13.glClientActiveTexture(par0);
GL13.glActiveTexture(par0);
}
}

@ -432,6 +432,7 @@ public abstract class Packet
addIdClassMapping(54, true, false, Packet54PlayNoteBlock.class);
addIdClassMapping(55, true, false, Packet55BlockDestroy.class);
addIdClassMapping(56, true, false, Packet56MapChunks.class);
addIdClassMapping(57, true, false, Packet57ExtraChunk.class);
addIdClassMapping(60, true, false, Packet60Explosion.class);
addIdClassMapping(61, true, false, Packet61DoorChange.class);
addIdClassMapping(62, true, false, Packet62LevelSound.class);

@ -0,0 +1,101 @@
package net.minecraft.src;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import org.mcmodule.math.BigInteger;
public class Packet57ExtraChunk extends Packet {
private byte[] blockLSB, blockMSB, metadata, skyLight, blockLight;
private BigInteger x, z;
private int y, blockRefCnt;
public Packet57ExtraChunk() {}
public Packet57ExtraChunk(BigInteger x, int y, BigInteger z, ExtendedBlockStorage storage) {
this.x = x;
this.y = y;
this.z = z;
this.blockLSB = storage.getBlockLSBArray();
this.blockMSB = storage.getBlockMSBArray().data;
this.metadata = storage.getMetadataArray().data;
this.skyLight = storage.getSkylightArray().data;
this.blockLight = storage.getBlocklightArray().data;
this.blockRefCnt = storage.getBlockRefCnt();
}
@Override
public void readPacketData(DataInputStream var1) throws IOException {
this.x = readBigInteger(var1);
this.y = var1.readInt();
this.z = readBigInteger(var1);
this.blockLSB = readBytesFromStream(var1);
this.blockMSB = readBytesFromStream(var1);
this.metadata = readBytesFromStream(var1);
this.skyLight = readBytesFromStream(var1);
this.blockLight = readBytesFromStream(var1);
this.blockRefCnt = var1.readInt();
}
@Override
public void writePacketData(DataOutputStream var1) throws IOException {
writeBigInteger(var1, this.x);
var1.writeInt(this.y);
writeBigInteger(var1, this.z);
writeByteArray(var1, this.blockLSB);
writeByteArray(var1, this.blockMSB);
writeByteArray(var1, this.metadata);
writeByteArray(var1, this.skyLight);
writeByteArray(var1, this.blockLight);
var1.writeInt(blockRefCnt);
}
@Override
public void processPacket(NetHandler var1) {
var1.handleAddExtraChunk(this);
}
@Override
public int getPacketSize() {
return 0;
}
public byte[] getBlockLSB() {
return blockLSB;
}
public byte[] getBlockMSB() {
return blockMSB;
}
public byte[] getMetadata() {
return metadata;
}
public byte[] getSkyLight() {
return skyLight;
}
public byte[] getBlockLight() {
return blockLight;
}
public BigInteger getX() {
return x;
}
public BigInteger getZ() {
return z;
}
public int getY() {
return y;
}
public int getBlockRefCnt() {
return blockRefCnt;
}
}

@ -3,12 +3,6 @@ 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) {
@ -21,16 +15,10 @@ 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 NoiseGeneratorPerlinDouble(random);
return new NoiseGeneratorPerlin2(random);
}
};

@ -3,6 +3,7 @@ package net.minecraft.src;
import org.mcmodule.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
class PlayerInstance
@ -48,7 +49,8 @@ class PlayerInstance
{
if (this.playersInChunk.contains(par1EntityPlayerMP))
{
par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet51MapChunk(PlayerManager.getWorldServer(this.myManager).getChunkFromChunkCoords(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos), true, 0));
Chunk chunk = PlayerManager.getWorldServer(this.myManager).getChunkFromChunkCoords(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos);
par1EntityPlayerMP.serverForThisPlayer.sendPacketToPlayer(new Packet51MapChunk(chunk, true, 0));
this.playersInChunk.remove(par1EntityPlayerMP);
par1EntityPlayerMP.chunksToLoad.remove(this.chunkLocation);
@ -63,6 +65,7 @@ class PlayerInstance
this.myManager.getWorldServer().theChunkProviderServer.unloadChunksIfNotNearSpawn(this.chunkLocation.chunkXPos, this.chunkLocation.chunkZPos);
}
}
// else System.out.println(this + " B");
}

@ -65,7 +65,7 @@ public class PlayerManager
}
}
private PlayerInstance getOrCreateChunkWatcher(BigInteger par1, BigInteger par2, boolean par3)
public PlayerInstance getOrCreateChunkWatcher(BigInteger par1, BigInteger par2, boolean par3)
{
ChunkCoordIntPair pos = new ChunkCoordIntPair(par1, par2);
PlayerInstance var6 = (PlayerInstance)this.allChunkWathers.get(pos);
@ -211,6 +211,7 @@ public class PlayerManager
BigInteger var3 = MathHelper.toBigInteger(par1EntityPlayerMP.posZBig).shiftRight(4);
// int var2 = (int)par1EntityPlayerMP.posX >> 4;
// int var3 = (int)par1EntityPlayerMP.posZ >> 4;
int y = (int)par1EntityPlayerMP.posY >> 4;
double var4 = par1EntityPlayerMP.field_71131_d.subtract(par1EntityPlayerMP.posXBig).doubleValue();
double var6 = par1EntityPlayerMP.field_71132_e.subtract(par1EntityPlayerMP.posZBig).doubleValue();
double var8 = var4 * var4 + var6 * var6;
@ -234,6 +235,10 @@ public class PlayerManager
if (!this.func_72684_a(var15, var16, var10, var11, var12))
{
this.getOrCreateChunkWatcher(var15, var16, true).addPlayerToChunkWatchingList(par1EntityPlayerMP);
Chunk chunk = theWorldServer.getChunkFromChunkCoords(var15, var16);
for(int var17 = y - this.playerViewDistance; var17 <= y + this.playerViewDistance; var17++) {
chunk.getBlockStorage(var17);
}
}
if (!this.func_72684_a(var15.subtract(var13), var16.subtract(var14), var2, var3, var12))

@ -551,9 +551,17 @@ public class RenderGlobal implements IWorldAccess
// this.maxBlockZ = var10;
// }
int sdfvhsdbvfhsdhkbdkjsakjdb = this.renderChunksTall * 16;
int kshdjiajdfjosjofjsdhvfssd = sdfvhsdbvfhsdhkbdkjsakjdb / 2;
for (int var12 = 0; var12 < this.renderChunksTall; ++var12)
{
int var13 = var12 * 16;
int var1000000000000000000000000 = var13 + kshdjiajdfjosjofjsdhvfssd - par2;
if (var1000000000000000000000000 < 0) {
var1000000000000000000000000 -= sdfvhsdbvfhsdhkbdkjsakjdb - 1;
}
var1000000000000000000000000 /= sdfvhsdbvfhsdhkbdkjsakjdb;
int y = var13 - var1000000000000000000000000 * sdfvhsdbvfhsdhkbdkjsakjdb;
// if (var13 < this.minBlockY)
// {
@ -567,7 +575,7 @@ public class RenderGlobal implements IWorldAccess
WorldRenderer var14 = this.worldRenderers[(var9 * this.renderChunksTall + var12) * this.renderChunksWide + var6];
boolean var15 = var14.needsUpdate;
var14.setPosition(x, var13, z);
var14.setPosition(x, y, z);
if (!var15 && var14.needsUpdate)
{ // WTF this is a unreachable code.
@ -861,7 +869,11 @@ public class RenderGlobal implements IWorldAccess
if (var17 < 0)
{
var17 = var14++;
if (var14 + 1 < 4) {
var17 = var14++;
} else {
var17 = 0;
}
this.allRenderLists[var17].func_78422_a(var22.posXMinus, var22.posYMinus, var22.posZMinus, var20, var10, var12);
}
}

@ -59,7 +59,7 @@ public class RenderList
{
GL11.glPushMatrix();
if(profiler != null) profiler.startSection("translate");
GL11.glTranslatef((float)(MathHelper.toBigDecimal(this.field_78429_a).subtract(this.field_78425_d).floatValue()), (float)((double)this.field_78427_b - this.field_78426_e), (float)(MathHelper.toBigDecimal(this.field_78428_c).subtract(this.field_78423_f).floatValue()));
GL11.glTranslated((float)(MathHelper.toBigDecimal(this.field_78429_a).subtract(this.field_78425_d).floatValue()), (this.field_78427_b - this.field_78426_e), (float)(MathHelper.toBigDecimal(this.field_78428_c).subtract(this.field_78423_f).floatValue()));
if(profiler != null) profiler.endStartSection("opengl");
GL11.glCallLists(this.field_78424_g);
if(profiler != null) profiler.endSection();

@ -145,10 +145,10 @@ public abstract class ServerConfigurationManager
this.playerEntityList.add(par1EntityPlayerMP);
WorldServer var2 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
while (!var2.getCollidingBoundingBoxes(par1EntityPlayerMP, ((Entity)par1EntityPlayerMP).boundingBox).isEmpty())
{
par1EntityPlayerMP.setPosition(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY + 1.0D, par1EntityPlayerMP.posZ);
}
// while (!var2.getCollidingBoundingBoxes(par1EntityPlayerMP, ((Entity)par1EntityPlayerMP).boundingBox).isEmpty())
// {
// par1EntityPlayerMP.setPosition(par1EntityPlayerMP.posX, par1EntityPlayerMP.posY + 1.0D, par1EntityPlayerMP.posZ);
// }
var2.spawnEntityInWorld(par1EntityPlayerMP);
this.func_72375_a(par1EntityPlayerMP, (WorldServer)null);

@ -256,7 +256,6 @@ public abstract class World implements IBlockAccess
*/
public int getBlockId(BigInteger par1, int par2, BigInteger par3)
{
if(par2 > 256 || par2 < 0) return 0;
return this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4)).getBlockID(par1.intValue() & 0xF, par2, par3.intValue() & 0xF);
}
@ -295,9 +294,8 @@ public abstract class World implements IBlockAccess
*/
public boolean doChunksNearChunkExist(BigInteger par1, int par2, BigInteger par3, int par4)
{
// return true;
BigInteger dist = BigInteger.valueOf(par4);
return this.checkChunksExist(par1.subtract(par3), par2 - par4, par3.subtract(dist), par1.add(dist), par2 + par4, par3.add(dist));
return true;
// return this.checkChunksExist(par1 - par4, par2 - par4, par3 - par4, par1 + par4, par2 + par4, par3 + par4);
}
/**
@ -346,29 +344,18 @@ public abstract class World implements IBlockAccess
*/
public boolean setBlockAndMetadataWithUpdate(BigInteger par1, int par2, BigInteger par3, int par4, int par5, boolean par6)
{
if (par2 < 0)
{
return false;
}
else if (par2 >= 256)
Chunk var7 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
boolean var8 = var7.setBlockIDWithMetadata(par1.intValue() & 0xF, par2, par3.intValue() & 0xF, par4, par5);
this.theProfiler.startSection("checkLight");
this.updateAllLightTypes(par1, par2, par3);
this.theProfiler.endSection();
if (par6 && var8 && (this.isRemote || var7.deferRender))
{
return false;
this.markBlockNeedsUpdate(par1, par2, par3);
}
else
{
Chunk var7 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
boolean var8 = var7.setBlockIDWithMetadata(par1.intValue() & 0xF, par2, par3.intValue() & 0xF, par4, par5);
this.theProfiler.startSection("checkLight");
this.updateAllLightTypes(par1, par2, par3);
this.theProfiler.endSection();
if (par6 && var8 && (this.isRemote || var7.deferRender))
{
this.markBlockNeedsUpdate(par1, par2, par3);
}
return var8;
}
return var8;
}
/**
@ -376,29 +363,18 @@ public abstract class World implements IBlockAccess
*/
public boolean setBlock(BigInteger par1, int par2, BigInteger par3, int par4)
{
if (par2 < 0)
{
return false;
}
else if (par2 >= 256)
Chunk var5 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
boolean var6 = var5.setBlockID(par1.intValue() & 0xF, par2, par3.intValue() & 0xF, par4);
this.theProfiler.startSection("checkLight");
this.updateAllLightTypes(par1, par2, par3);
this.theProfiler.endSection();
if (var6 && (this.isRemote || var5.deferRender))
{
return false;
this.markBlockNeedsUpdate(par1, par2, par3);
}
else
{
Chunk var5 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
boolean var6 = var5.setBlockID(par1.intValue() & 0xF, par2, par3.intValue() & 0xF, par4);
this.theProfiler.startSection("checkLight");
this.updateAllLightTypes(par1, par2, par3);
this.theProfiler.endSection();
if (var6 && (this.isRemote || var5.deferRender))
{
this.markBlockNeedsUpdate(par1, par2, par3);
}
return var6;
}
return var6;
}
/**
@ -415,19 +391,8 @@ public abstract class World implements IBlockAccess
*/
public int getBlockMetadata(BigInteger par1, int par2, BigInteger par3)
{
if (par2 < 0)
{
return 0;
}
else if (par2 >= 256)
{
return 0;
}
else
{
Chunk var4 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
return var4.getBlockMetadata(par1.intValue() & 0xF, par2, par3.intValue() & 0xF);
}
Chunk var4 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
return var4.getBlockMetadata(par1.intValue() & 0xF, par2, par3.intValue() & 0xF);
}
/**
@ -446,28 +411,17 @@ public abstract class World implements IBlockAccess
*/
public boolean setBlockMetadata(BigInteger par1, int par2, BigInteger par3, int par4)
{
if (par2 < 0)
{
return false;
}
else if (par2 >= 256)
Chunk var5 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
int var6 = par1.intValue() & 0xF;
int var7 = par3.intValue() & 0xF;
boolean var8 = var5.setBlockMetadata(var6, par2, var7, par4);
if (var8 && (this.isRemote || var5.deferRender && Block.requiresSelfNotify[var5.getBlockID(var6, par2, var7) & 4095]))
{
return false;
this.markBlockNeedsUpdate(par1, par2, par3);
}
else
{
Chunk var5 = this.getChunkFromChunkCoords(par1.shiftRight(4), par3.shiftRight(4));
int var6 = par1.intValue() & 0xF;
int var7 = par3.intValue() & 0xF;
boolean var8 = var5.setBlockMetadata(var6, par2, var7, par4);
if (var8 && (this.isRemote || var5.deferRender && Block.requiresSelfNotify[var5.getBlockID(var6, par2, var7) & 4095]))
{
this.markBlockNeedsUpdate(par1, par2, par3);
}
return var8;
}
return var8;
}
/**
@ -1760,7 +1714,6 @@ public abstract class World implements IBlockAccess
for (var1 = 0; var1 < this.loadedEntityList.size(); ++var1)
{
var2 = (Entity)this.loadedEntityList.get(var1);
if (!(var2 instanceof EntityPlayer) && Constants.DISABLE_ENTITY_UPDATE) continue;
if (var2.ridingEntity != null)
{
@ -3880,4 +3833,8 @@ public abstract class World implements IBlockAccess
var7.destroyBlockPartially(par1, par2, par3, par4, par5);
}
}
public void addExtraChunk(BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
chunkProvider.generateExtraBlockStorage(x, y, z, blockStorage);
}
}

@ -107,7 +107,7 @@ public class WorldRenderer
this.posYPlus = par2 + 8;
this.posZPlus = par3.add(BigInteger.valueOf(8));
this.posXClip = par1.intValue() & 1023;
this.posYClip = par2;
this.posYClip = par2 & 1023;
this.posZClip = par3.intValue() & 1023;
this.posXMinus = par1.subtract(BigInteger.valueOf(posXClip));
this.posYMinus = par2 - this.posYClip;
@ -317,7 +317,9 @@ public class WorldRenderer
public void updateInFrustum(ICamera par1ICamera)
{
// long time = System.currentTimeMillis();
this.isInFrustum = par1ICamera.isBoundingBoxInFrustum(this.rendererBoundingBox);
// System.out.println("> " + (System.currentTimeMillis() - time));
}
/**

@ -553,6 +553,17 @@ public class WorldServer extends World
this.theChunkProviderServer = new ChunkProviderServer(this, var1, this.provider.getChunkProvider());
return this.theChunkProviderServer;
}
public void addExtraChunk(BigInteger x, int y, BigInteger z, ExtendedBlockStorage blockStorage) {
// long time = System.currentTimeMillis();
super.addExtraChunk(x, y, z, blockStorage);
// System.out.println(System.currentTimeMillis() - time);
if(thePlayerManager == null || blockStorage.isEmpty()) return;
PlayerInstance instance = thePlayerManager.getOrCreateChunkWatcher(x, z, false);
if(instance != null) {
instance.sendToAllPlayersWatchingChunk(new Packet57ExtraChunk(x, y, z, blockStorage));
}
}
/**
* pars: min x,y,z , max x,y,z

Loading…
Cancel
Save