- 769
- 1
- 42
В общем создал свое измерение(переходил с 1.6.4) и мир попросту не загружается, естественно я изменил все максимально по стандартам 1.7.10, но чего-то, чего-то не але, майн начинает жрать RAM и давиться ей параллельно. В логах пусто, никогда с такой бедой не сталкивался. Прошу помочь чем есть.
Вот вам ChunkProvider:
Вот вам ChunkProvider:
Код:
package vacuum.planets.world.mercury.gen;
import java.util.List;
import java.util.Random;
import micdoodle8.mods.galacticraft.core.perlin.generator.Gradient;
import micdoodle8.mods.galacticraft.core.world.gen.EnumCraterSize;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFalling;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.init.Blocks;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.util.MathHelper;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.WorldType;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.NoiseGeneratorOctaves;
import net.minecraft.world.gen.NoiseGeneratorPerlin;
import vacuum.planets.core.PlanetsBlocks;
import vacuum.planets.core.biome.PlanetsBiomeGenBase;
public class MercuryChunkProvider implements IChunkProvider {
private Random rand;
private NoiseGeneratorOctaves noiseGen1;
private NoiseGeneratorOctaves noiseGen2;
private NoiseGeneratorOctaves noiseGen3;
private NoiseGeneratorOctaves noiseGen4;
private NoiseGeneratorPerlin noisePerl;
public NoiseGeneratorOctaves noiseGen5;
public NoiseGeneratorOctaves noiseGen6;
private Gradient noiseCGen5;
private World worldObj;
private final boolean mapFeaturesEnabled;
private WorldType worldType;
private final double[] noiseArray;
private final float[] parabolicField;
private double[] stoneNoise = new double[256];
private double[] terrainCalcs;
private final MercuryCaveGen caveGenerator = new MercuryCaveGen();
private BiomeGenBase[] biomesForGeneration;
double[] noise3;
double[] noise1;
double[] noise2;
double[] noise5;
int[][] field_73219_j = new int[32][32];
public MercuryChunkProvider(World world, long seed, boolean mapFeaturesEnabled) {
this.worldObj = world;
this.mapFeaturesEnabled = mapFeaturesEnabled;
this.worldType = world.getWorldInfo().getTerrainType();
this.rand = new Random(seed);
this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);
this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);
this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, 8);
this.noisePerl = new NoiseGeneratorPerlin(this.rand, 4);
this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
this.noiseCGen5 = new Gradient(this.rand.nextLong(), 1, (float) 0.25);
this.noiseArray = new double[825];
this.parabolicField = new float[25];
for (int j = -2; j <= 2; ++j) {
for (int k = -2; k <= 2; ++k) {
float f = 10.0F / MathHelper.sqrt_float((float)(j * j + k * k) + 0.2F);
this.parabolicField[j + 2 + (k + 2) * 5] = f;
}
}
}
public double getHeightModifier() {
return 0;
}
public int getWaterLevel() {
return 0;
}
public void generateTerrain(int chunkX, int chunkZ, Block[] blockStorage, byte[] metaStorage) {
int seaLevel = this.getWaterLevel();
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, chunkX * 4 - 2, chunkZ * 4 - 2, 10, 10);
this.makeLandPerBiome2(chunkX * 4, 0, chunkZ * 4);
for(int k = 0; k < 4; ++k) {
int l = k * 5;
int i1 = (k + 1) * 5;
for(int j1 = 0; j1 < 4; ++j1) {
int k1 = (l + j1) * 33;
int l1 = (l + j1 + 1) * 33;
int i2 = (i1 + j1) * 33;
int j2 = (i1 + j1 + 1) * 33;
for(int k2 = 0; k2 < 32; ++k2) {
double d0 = 0.125D;
double d1 = this.terrainCalcs[k1 + k2];
double d2 = this.terrainCalcs[l1 + k2];
double d3 = this.terrainCalcs[i2 + k2];
double d4 = this.terrainCalcs[j2 + k2];
double d5 = (this.terrainCalcs[k1 + k2 + 1] - d1) * d0;
double d6 = (this.terrainCalcs[l1 + k2 + 1] - d2) * d0;
double d7 = (this.terrainCalcs[i2 + k2 + 1] - d3) * d0;
double d8 = (this.terrainCalcs[j2 + k2 + 1] - d4) * d0;
for(int l2 = 0; l2 < 8; ++l2) {
double d9 = 0.25D;
double d10 = d1;
double d11 = d2;
double d12 = (d3 - d1) * d9;
double d13 = (d4 - d2) * d9;
for(int i3 = 0; i3 < 4; ++i3) {
int j3 = i3 + k * 4 << 12 | 0 + j1 * 4 << 8 | k2 * 8 + l2;
short short1 = 256;
j3 -= short1;
double d14 = 0.25D;
double d16 = (d11 - d10) * d14;
double d15 = d10 - d16;
for(int k3 = 0; k3 < 4; ++k3) {
if((d15 += d16) > 0.0D) {
blockStorage[j3 += short1] = PlanetsBlocks.planetBottom;
} else if(k2 * 8 + l2 < seaLevel) {
metaStorage[j3 += short1] = 0;
} else {
blockStorage[j3 += short1] = null;
}
}
d10 += d12;
d11 += d13;
}
d1 += d5;
d2 += d6;
d3 += d7;
d4 += d8;
}
}
}
}
}
public void replaceBlocksForBiome(int par1, int par2, Block[] arrayOfIDs, byte[] arrayOfMeta, BiomeGenBase[] par4ArrayOfBiomeGenBase) {
final int var5 = 20;
final float var6 = 0.03125F;
this.noiseCGen5.setFrequency(var6 * 2);
for (int var8 = 0; var8 < 16; ++var8) {
for (int var9 = 0; var9 < 16; ++var9) {
PlanetsBiomeGenBase biomegenbase = (PlanetsBiomeGenBase)par4ArrayOfBiomeGenBase[var8 + var9 * 16];
int var12 = (int)((double)this.noiseCGen5.getNoise((float)(par1 * 16 + var8), (float)(par2 * 16 + var9)) / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);
int var13 = -1;
Block var14 = biomegenbase.topBlock;
byte var14m = biomegenbase.topBlockMeta;
Block var15 = biomegenbase.fillerBlock;
byte var15m = biomegenbase.fillerBlockMeta;
for (int var16 = 256 - 1; var16 >= 0; --var16) {
final int index = this.getIndex(var8, var16, var9);
if (var16 <= 0 + this.rand.nextInt(5)) {
arrayOfIDs[index] = Blocks.bedrock;
} else {
final Block var18 = arrayOfIDs[index];
if (Blocks.air == var18) {
var13 = -1;
} else if (var18 == PlanetsBlocks.planetBottom) {
arrayOfMeta[index] = 0;
if (var13 == -1) {
if (var12 <= 0) {
var14 = Blocks.air;
var14m = 0;
var15 = PlanetsBlocks.planetBottom;
var15m = 0;
} else if (var16 >= var5 - -16 && var16 <= var5 + 1) {
var14 = biomegenbase.topBlock;
var14m = biomegenbase.topBlockMeta;
var14 = biomegenbase.fillerBlock;
var14m = biomegenbase.fillerBlockMeta;
}
var13 = var12;
if (var16 >= var5 - 1) {
arrayOfIDs[index] = var14;
arrayOfMeta[index] = var14m;
} else {
arrayOfIDs[index] = var15;
arrayOfMeta[index] = var15m;
}
} else if (var13 > 0) {
--var13;
arrayOfIDs[index] = var15;
arrayOfMeta[index] = var15m;
}
}
}
}
}
}
}
private void makeLandPerBiome2(int x, int zero, int z) {
this.noise5 = this.noiseGen3.generateNoiseOctaves(this.noise5, x, z, 5, 5, 200.0D, 200.0D, 0.5D);
this.noise3 = this.noiseGen4.generateNoiseOctaves(this.noise3, x, zero, z, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);
this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, x, zero, z, 5, 33, 5, 684.412D, 684.412D, 684.412D);
this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, x, zero, z, 5, 33, 5, 684.412D, 684.412D, 684.412D);
int terrainIndex = 0;
int noiseIndex = 0;
for(int ax = 0; ax < 5; ++ax) {
for(int az = 0; az < 5; ++az) {
float totalVariation = 0.0F;
float totalHeight = 0.0F;
float totalFactor = 0.0F;
byte two = 2;
BiomeGenBase biomegenbase = this.biomesForGeneration[ax + 2 + (az + 2) * 10];
for(int terrainNoise = -two; terrainNoise <= two; ++terrainNoise) {
for(int oz = -two; oz <= two; ++oz) {
BiomeGenBase heightCalc = this.biomesForGeneration[ax + terrainNoise + 2 + (az + oz + 2) * 10];
float rootHeight = heightCalc.rootHeight;
float variationCalc = heightCalc.heightVariation;
float heightFactor = this.parabolicField[terrainNoise + 2 + (oz + 2) * 5] / (rootHeight + 2.0F);
if(heightCalc.rootHeight > biomegenbase.rootHeight) {
heightFactor /= 2.0F;
}
totalVariation += variationCalc * heightFactor;
totalHeight += rootHeight * heightFactor;
totalFactor += heightFactor;
}
}
totalVariation /= totalFactor;
totalHeight /= totalFactor;
totalVariation = totalVariation * 0.9F + 0.1F;
totalHeight = (totalHeight * 4.0F - 1.0F) / 8.0F;
double var34 = this.noise5[noiseIndex] / 8000.0D;
if(var34 < 0.0D) {
var34 = -var34 * 0.3D;
}
var34 = var34 * 3.0D - 2.0D;
if(var34 < 0.0D) {
var34 /= 2.0D;
if(var34 < -1.0D) {
var34 = -1.0D;
}
var34 /= 1.4D;
var34 /= 2.0D;
} else {
if(var34 > 1.0D) {
var34 = 1.0D;
}
var34 /= 8.0D;
}
++noiseIndex;
double var35 = (double)totalHeight;
double var36 = (double)totalVariation * this.getHeightModifier() / 10.0D;
var35 += var34 * 0.2D;
var35 = var35 * 8.5D / 8.0D;
double d5 = 8.5D + var35 * 4.0D;
for(int ay = 0; ay < 33; ++ay) {
double d6 = ((double)ay - d5) * 12.0D * 128.0D / 256.0D / var36;
if(d6 < 0.0D) {
d6 *= 4.0D;
}
double d7 = this.noise1[terrainIndex] / 512.0D;
double d8 = this.noise2[terrainIndex] / 512.0D;
double d9 = (this.noise3[terrainIndex] / 10.0D + 1.0D) / 2.0D;
double terrainCalc = MathHelper.denormalizeClamp(d7, d8, d9) - d6;
if(ay > 29) {
double d11 = (double)((float)(ay - 29) / 3.0F);
terrainCalc = terrainCalc * (1.0D - d11) + -10.0D * d11;
}
this.terrainCalcs[terrainIndex] = terrainCalc;
++terrainIndex;
}
}
}
}
public void createCraters(int chunkX, int chunkZ, Block[] chunkArray, byte[] metaArray) {
for (int cx = chunkX - 2; cx <= chunkX + 2; cx++) {
for (int cz = chunkZ - 2; cz <= chunkZ + 2; cz++) {
for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
if (Math.abs(this.randFromPoint(cx * 16 + x, (cz * 16 + z) * 1000)) < this.noiseCGen5.getNoise(x * 16 + x, cz * 16 + z) / 2500) {
final Random random = new Random(cx * 16 + x + (cz * 16 + z) * 5000);
final EnumCraterSize cSize = EnumCraterSize.sizeArray[random.nextInt(EnumCraterSize.sizeArray.length)];
final int size = random.nextInt(cSize.MAX_SIZE - cSize.MIN_SIZE) + cSize.MIN_SIZE;
this.makeCrater(cx * 16 + x, cz * 16 + z, chunkX * 16, chunkZ * 16, size, chunkArray, metaArray);
}
}
}
}
}
}
public void makeCrater(int craterX, int craterZ, int chunkX, int chunkZ, int size, Block[] chunkArray, byte[] metaArray) {
for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
double xDev = craterX - (chunkX + x);
double zDev = craterZ - (chunkZ + z);
if (xDev * xDev + zDev * zDev < size * size) {
xDev /= size;
zDev /= size;
final double sqrtY = xDev * xDev + zDev * zDev;
double yDev = sqrtY * sqrtY * 6;
yDev = 5 - yDev;
int helper = 0;
for (int y = 127; y > 0; y--) {
if (Blocks.air != chunkArray[this.getIndex(x, y, z)] && helper <= yDev) {
chunkArray[this.getIndex(x, y, z)] = Blocks.air;
metaArray[this.getIndex(x, y, z)] = 0;
helper++;
}
if (helper > yDev) {
break;
}
}
}
}
}
}
@Override
public Chunk provideChunk(int par1, int par2) {
this.rand.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
Block[] ablock = new Block[65536];
byte[] abyte = new byte[65536];
this.generateTerrain(par1, par2, ablock, abyte);
this.createCraters(par1, par2, ablock, abyte);
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
this.replaceBlocksForBiome(par1, par2, ablock, abyte, this.biomesForGeneration);
this.caveGenerator.generate(this, this.worldObj, par1, par2, ablock, abyte);
if (this.mapFeaturesEnabled) {
}
Chunk chunk = new Chunk(this.worldObj, ablock, abyte, par1, par2);
byte[] abyte1 = chunk.getBiomeArray();
for (int k = 0; k < abyte1.length; ++k){
abyte1[k] = (byte)this.biomesForGeneration[k].biomeID;
}
chunk.generateSkylightMap();
return chunk;
}
@Override
public void populate(IChunkProvider par1IChunkProvider, int par2, int par3) {
BlockFalling.fallInstantly = true;
int k = par2 * 16;
int l = par3 * 16;
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(k + 16, l + 16);
this.rand.setSeed(this.worldObj.getSeed());
long i1 = this.rand.nextLong() / 2L * 2L + 1L;
long j1 = this.rand.nextLong() / 2L * 2L + 1L;
this.rand.setSeed((long)par2 * i1 + (long)par3 * j1 ^ this.worldObj.getSeed());
boolean flag = false;
BlockFalling.fallInstantly = false;
}
private double randFromPoint(int x, int z) {
int n;
n = x + z * 57;
n = n << 13 ^ n;
return 1.0 - (n * (n * n * 15731 + 789221) + 1376312589 & 0x7fffffff) / 1073741824.0;
}
private int getIndex(int x, int y, int z) {
return y << 8 | z << 4 | x;
}
@Override
public Chunk loadChunk(int par1, int par2) {
return this.provideChunk(par1, par2);
}
@Override
public boolean chunkExists(int par1, int par2) {
return true;
}
@Override
public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate) {
return true;
}
@Override
public void saveExtraData() {}
@Override
public boolean unloadQueuedChunks() {
return false;
}
@Override
public boolean canSave() {
return true;
}
@Override
public String makeString() {
return "RandomLevelSource";
}
@SuppressWarnings("rawtypes")
@Override
public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4) {
return null;
}
@Override
public int getLoadedChunkCount() {
return 0;
}
@Override
public void recreateStructures(int par1, int par2) {
if (this.mapFeaturesEnabled) {
}
}
@Override
public ChunkPosition func_147416_a(World world, String arg1, int arg2, int arg3, int arg4) {
return null;
}
}
