-
-
Save anonymous/66b89c456e2585a1386f9aa2792ba574 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package com.chocolatemod.worldgen; | |
import java.util.List; | |
import java.util.Random; | |
import com.chocolatemod.init.ChocolateBlocks; | |
import net.minecraft.block.Block; | |
import net.minecraft.block.BlockFalling; | |
import net.minecraft.entity.EnumCreatureType; | |
import net.minecraft.init.Blocks; | |
import net.minecraft.util.BlockPos; | |
import net.minecraft.util.IProgressUpdate; | |
import net.minecraft.util.MathHelper; | |
import net.minecraft.world.ChunkCoordIntPair; | |
import net.minecraft.world.SpawnerAnimals; | |
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.ChunkPrimer; | |
import net.minecraft.world.chunk.IChunkProvider; | |
import net.minecraft.world.gen.ChunkProviderSettings; | |
import net.minecraft.world.gen.MapGenBase; | |
import net.minecraft.world.gen.NoiseGenerator; | |
import net.minecraft.world.gen.NoiseGeneratorOctaves; | |
import net.minecraft.world.gen.NoiseGeneratorPerlin; | |
import net.minecraft.world.gen.feature.WorldGenDungeons; | |
import net.minecraft.world.gen.feature.WorldGenLakes; | |
import net.minecraft.world.gen.structure.MapGenMineshaft; | |
import net.minecraft.world.gen.structure.MapGenScatteredFeature; | |
import net.minecraft.world.gen.structure.MapGenStronghold; | |
import net.minecraft.world.gen.structure.MapGenVillage; | |
import net.minecraft.world.gen.structure.StructureOceanMonument; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*; | |
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*; | |
import net.minecraftforge.common.*; | |
import net.minecraftforge.fml.common.eventhandler.Event.*; | |
import net.minecraftforge.event.terraingen.*; | |
public class ChunkProviderChocolate implements IChunkProvider | |
{ | |
/** RNG. */ | |
private Random rand; | |
private NoiseGeneratorOctaves field_147431_j; | |
private NoiseGeneratorOctaves field_147432_k; | |
private NoiseGeneratorOctaves field_147429_l; | |
private NoiseGeneratorPerlin field_147430_m; | |
/** A NoiseGeneratorOctaves used in generating terrain */ | |
public NoiseGeneratorOctaves noiseGen5; | |
/** A NoiseGeneratorOctaves used in generating terrain */ | |
public NoiseGeneratorOctaves noiseGen6; | |
public NoiseGeneratorOctaves mobSpawnerNoise; | |
/** Reference to the World object. */ | |
private World worldObj; | |
/** are map structures going to be generated (e.g. strongholds) */ | |
private final boolean mapFeaturesEnabled; | |
private WorldType field_177475_o; | |
private final double[] field_147434_q; | |
private final float[] parabolicField; | |
private ChunkProviderSettings settings; | |
private Block field_177476_s; | |
private double[] stoneNoise; | |
private MapGenBase caveGenerator; | |
/** Holds Stronghold Generator */ | |
private MapGenStronghold strongholdGenerator; | |
/** Holds Village Generator */ | |
private MapGenVillage villageGenerator; | |
/** Holds Mineshaft Generator */ | |
private MapGenMineshaft mineshaftGenerator; | |
private MapGenScatteredFeature scatteredFeatureGenerator; | |
/** Holds ravine generator */ | |
private MapGenBase ravineGenerator; | |
private StructureOceanMonument oceanMonumentGenerator; | |
/** The biomes that are used to generate the chunk */ | |
private BiomeGenBase[] biomesForGeneration; | |
double[] field_147427_d; | |
double[] field_147428_e; | |
double[] field_147425_f; | |
double[] field_147426_g; | |
private static final String __OBFID = "CL_00000396"; | |
public ChunkProviderChocolate(World worldIn, long p_i45636_2_, boolean p_i45636_4_, String p_i45636_5_) | |
{ | |
this.field_177476_s = Blocks.water; | |
this.stoneNoise = new double[256]; | |
this.caveGenerator = new MapGenChocolateCaves(); | |
this.strongholdGenerator = new MapGenStronghold(); | |
this.villageGenerator = new MapGenVillage(); | |
this.mineshaftGenerator = new MapGenMineshaft(); | |
this.scatteredFeatureGenerator = new MapGenScatteredFeature(); | |
this.ravineGenerator = new MapGenChocolateRavine(); | |
this.oceanMonumentGenerator = new StructureOceanMonument(); | |
{ | |
caveGenerator = TerrainGen.getModdedMapGen(caveGenerator, CAVE); | |
strongholdGenerator = (MapGenStronghold)TerrainGen.getModdedMapGen(strongholdGenerator, STRONGHOLD); | |
villageGenerator = (MapGenVillage)TerrainGen.getModdedMapGen(villageGenerator, VILLAGE); | |
mineshaftGenerator = (MapGenMineshaft)TerrainGen.getModdedMapGen(mineshaftGenerator, MINESHAFT); | |
scatteredFeatureGenerator = (MapGenScatteredFeature)TerrainGen.getModdedMapGen(scatteredFeatureGenerator, SCATTERED_FEATURE); | |
ravineGenerator = TerrainGen.getModdedMapGen(ravineGenerator, RAVINE); | |
oceanMonumentGenerator = (StructureOceanMonument)TerrainGen.getModdedMapGen(oceanMonumentGenerator, OCEAN_MONUMENT); | |
} | |
this.worldObj = worldIn; | |
this.mapFeaturesEnabled = p_i45636_4_; | |
this.field_177475_o = worldIn.getWorldInfo().getTerrainType(); | |
this.rand = new Random(p_i45636_2_); | |
this.field_147431_j = new NoiseGeneratorOctaves(this.rand, 16); | |
this.field_147432_k = new NoiseGeneratorOctaves(this.rand, 16); | |
this.field_147429_l = new NoiseGeneratorOctaves(this.rand, 8); | |
this.field_147430_m = new NoiseGeneratorPerlin(this.rand, 4); | |
this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10); | |
this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16); | |
this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8); | |
this.field_147434_q = 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; | |
} | |
} | |
if (p_i45636_5_ != null) | |
{ | |
this.settings = ChunkProviderSettings.Factory.func_177865_a(p_i45636_5_).func_177864_b(); | |
this.field_177476_s = this.settings.useLavaOceans ? Blocks.lava : Blocks.water; | |
} | |
NoiseGenerator[] noiseGens = {field_147431_j, field_147432_k, field_147429_l, field_147430_m, noiseGen5, noiseGen6, mobSpawnerNoise}; | |
noiseGens = TerrainGen.getModdedNoiseGenerators(worldIn, this.rand, noiseGens); | |
this.field_147431_j = (NoiseGeneratorOctaves)noiseGens[0]; | |
this.field_147432_k = (NoiseGeneratorOctaves)noiseGens[1]; | |
this.field_147429_l = (NoiseGeneratorOctaves)noiseGens[2]; | |
this.field_147430_m = (NoiseGeneratorPerlin)noiseGens[3]; | |
this.noiseGen5 = (NoiseGeneratorOctaves)noiseGens[4]; | |
this.noiseGen6 = (NoiseGeneratorOctaves)noiseGens[5]; | |
this.mobSpawnerNoise = (NoiseGeneratorOctaves)noiseGens[6]; | |
} | |
public void setBlocksInChunk(int p_180518_1_, int p_180518_2_, ChunkPrimer p_180518_3_) | |
{ | |
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, p_180518_1_ * 4 - 2, p_180518_2_ * 4 - 2, 10, 10); | |
this.func_147423_a(p_180518_1_ * 4, 0, p_180518_2_ * 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.field_147434_q[k1 + k2]; | |
double d2 = this.field_147434_q[l1 + k2]; | |
double d3 = this.field_147434_q[i2 + k2]; | |
double d4 = this.field_147434_q[j2 + k2]; | |
double d5 = (this.field_147434_q[k1 + k2 + 1] - d1) * d0; | |
double d6 = (this.field_147434_q[l1 + k2 + 1] - d2) * d0; | |
double d7 = (this.field_147434_q[i2 + k2 + 1] - d3) * d0; | |
double d8 = (this.field_147434_q[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) | |
{ | |
double d14 = 0.25D; | |
double d16 = (d11 - d10) * d14; | |
double d15 = d10 - d16; | |
for (int j3 = 0; j3 < 4; ++j3) | |
{ | |
if ((d15 += d16) > 0.0D) | |
{ | |
p_180518_3_.setBlockState(k * 4 + i3, k2 * 8 + l2, j1 * 4 + j3, ChocolateBlocks.chocoStone.getStateFromMeta(1)); | |
} | |
else if (k2 * 8 + l2 < this.settings.seaLevel) | |
{ | |
p_180518_3_.setBlockState(k * 4 + i3, k2 * 8 + l2, j1 * 4 + j3, this.field_177476_s.getDefaultState()); | |
} | |
} | |
d10 += d12; | |
d11 += d13; | |
} | |
d1 += d5; | |
d2 += d6; | |
d3 += d7; | |
d4 += d8; | |
} | |
} | |
} | |
} | |
} | |
public void func_180517_a(int p_180517_1_, int p_180517_2_, ChunkPrimer p_180517_3_, BiomeGenBase[] p_180517_4_) | |
{ | |
ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, p_180517_1_, p_180517_2_, p_180517_3_, this.worldObj); | |
MinecraftForge.EVENT_BUS.post(event); | |
if (event.getResult() == Result.DENY) return; | |
double d0 = 0.03125D; | |
this.stoneNoise = this.field_147430_m.func_151599_a(this.stoneNoise, (double)(p_180517_1_ * 16), (double)(p_180517_2_ * 16), 16, 16, d0 * 2.0D, d0 * 2.0D, 1.0D); | |
for (int k = 0; k < 16; ++k) | |
{ | |
for (int l = 0; l < 16; ++l) | |
{ | |
BiomeGenBase biomegenbase = p_180517_4_[l + k * 16]; | |
biomegenbase.genTerrainBlocks(this.worldObj, this.rand, p_180517_3_, p_180517_1_ * 16 + k, p_180517_2_ * 16 + l, this.stoneNoise[l + k * 16]); | |
} | |
} | |
} | |
/** | |
* Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the | |
* specified chunk from the map seed and chunk seed | |
*/ | |
public Chunk provideChunk(int x, int z) | |
{ | |
this.rand.setSeed((long)x * 341873128712L + (long)z * 132897987541L); | |
ChunkPrimer chunkprimer = new ChunkPrimer(); | |
this.setBlocksInChunk(x, z, chunkprimer); | |
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, x * 16, z * 16, 16, 16); | |
this.func_180517_a(x, z, chunkprimer, this.biomesForGeneration); | |
if (this.settings.useCaves) | |
{ | |
this.caveGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
if (this.settings.useRavines) | |
{ | |
this.ravineGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
if (this.settings.useMineShafts && this.mapFeaturesEnabled) | |
{ | |
this.mineshaftGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
if (this.settings.useVillages && this.mapFeaturesEnabled) | |
{ | |
this.villageGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
if (this.settings.useStrongholds && this.mapFeaturesEnabled) | |
{ | |
this.strongholdGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
if (this.settings.useTemples && this.mapFeaturesEnabled) | |
{ | |
this.scatteredFeatureGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
if (this.settings.useMonuments && this.mapFeaturesEnabled) | |
{ | |
this.oceanMonumentGenerator.func_175792_a(this, this.worldObj, x, z, chunkprimer); | |
} | |
Chunk chunk = new Chunk(this.worldObj, chunkprimer, x, z); | |
byte[] abyte = chunk.getBiomeArray(); | |
for (int k = 0; k < abyte.length; ++k) | |
{ | |
abyte[k] = (byte)this.biomesForGeneration[k].biomeID; | |
} | |
chunk.generateSkylightMap(); | |
return chunk; | |
} | |
private void func_147423_a(int p_147423_1_, int p_147423_2_, int p_147423_3_) | |
{ | |
this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, p_147423_1_, p_147423_3_, 5, 5, (double)this.settings.depthNoiseScaleX, (double)this.settings.depthNoiseScaleZ, (double)this.settings.depthNoiseScaleExponent); | |
float f = this.settings.coordinateScale; | |
float f1 = this.settings.heightScale; | |
this.field_147427_d = this.field_147429_l.generateNoiseOctaves(this.field_147427_d, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, (double)(f / this.settings.mainNoiseScaleX), (double)(f1 / this.settings.mainNoiseScaleY), (double)(f / this.settings.mainNoiseScaleZ)); | |
this.field_147428_e = this.field_147431_j.generateNoiseOctaves(this.field_147428_e, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, (double)f, (double)f1, (double)f); | |
this.field_147425_f = this.field_147432_k.generateNoiseOctaves(this.field_147425_f, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, (double)f, (double)f1, (double)f); | |
boolean flag1 = false; | |
boolean flag = false; | |
int l = 0; | |
int i1 = 0; | |
for (int j1 = 0; j1 < 5; ++j1) | |
{ | |
for (int k1 = 0; k1 < 5; ++k1) | |
{ | |
float f2 = 0.0F; | |
float f3 = 0.0F; | |
float f4 = 0.0F; | |
byte b0 = 2; | |
BiomeGenBase biomegenbase = this.biomesForGeneration[j1 + 2 + (k1 + 2) * 10]; | |
for (int l1 = -b0; l1 <= b0; ++l1) | |
{ | |
for (int i2 = -b0; i2 <= b0; ++i2) | |
{ | |
BiomeGenBase biomegenbase1 = this.biomesForGeneration[j1 + l1 + 2 + (k1 + i2 + 2) * 10]; | |
float f5 = this.settings.biomeDepthOffSet + biomegenbase1.minHeight * this.settings.biomeDepthWeight; | |
float f6 = this.settings.biomeScaleOffset + biomegenbase1.maxHeight * this.settings.biomeScaleWeight; | |
if (this.field_177475_o == WorldType.AMPLIFIED && f5 > 0.0F) | |
{ | |
f5 = 1.0F + f5 * 2.0F; | |
f6 = 1.0F + f6 * 4.0F; | |
} | |
float f7 = this.parabolicField[l1 + 2 + (i2 + 2) * 5] / (f5 + 2.0F); | |
if (biomegenbase1.minHeight > biomegenbase.minHeight) | |
{ | |
f7 /= 2.0F; | |
} | |
f2 += f6 * f7; | |
f3 += f5 * f7; | |
f4 += f7; | |
} | |
} | |
f2 /= f4; | |
f3 /= f4; | |
f2 = f2 * 0.9F + 0.1F; | |
f3 = (f3 * 4.0F - 1.0F) / 8.0F; | |
double d7 = this.field_147426_g[i1] / 8000.0D; | |
if (d7 < 0.0D) | |
{ | |
d7 = -d7 * 0.3D; | |
} | |
d7 = d7 * 3.0D - 2.0D; | |
if (d7 < 0.0D) | |
{ | |
d7 /= 2.0D; | |
if (d7 < -1.0D) | |
{ | |
d7 = -1.0D; | |
} | |
d7 /= 1.4D; | |
d7 /= 2.0D; | |
} | |
else | |
{ | |
if (d7 > 1.0D) | |
{ | |
d7 = 1.0D; | |
} | |
d7 /= 8.0D; | |
} | |
++i1; | |
double d8 = (double)f3; | |
double d9 = (double)f2; | |
d8 += d7 * 0.2D; | |
d8 = d8 * (double)this.settings.baseSize / 8.0D; | |
double d0 = (double)this.settings.baseSize + d8 * 4.0D; | |
for (int j2 = 0; j2 < 33; ++j2) | |
{ | |
double d1 = ((double)j2 - d0) * (double)this.settings.stretchY * 128.0D / 256.0D / d9; | |
if (d1 < 0.0D) | |
{ | |
d1 *= 4.0D; | |
} | |
double d2 = this.field_147428_e[l] / (double)this.settings.lowerLimitScale; | |
double d3 = this.field_147425_f[l] / (double)this.settings.upperLimitScale; | |
double d4 = (this.field_147427_d[l] / 10.0D + 1.0D) / 2.0D; | |
double d5 = MathHelper.denormalizeClamp(d2, d3, d4) - d1; | |
if (j2 > 29) | |
{ | |
double d6 = (double)((float)(j2 - 29) / 3.0F); | |
d5 = d5 * (1.0D - d6) + -10.0D * d6; | |
} | |
this.field_147434_q[l] = d5; | |
++l; | |
} | |
} | |
} | |
} | |
/** | |
* Checks to see if a chunk exists at x, z | |
*/ | |
public boolean chunkExists(int x, int z) | |
{ | |
return true; | |
} | |
/** | |
* Populates chunk with ores etc etc | |
*/ | |
public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_) | |
{ | |
BlockFalling.fallInstantly = true; | |
int k = p_73153_2_ * 16; | |
int l = p_73153_3_ * 16; | |
BlockPos blockpos = new BlockPos(k, 0, l); | |
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(blockpos.add(16, 0, 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)p_73153_2_ * i1 + (long)p_73153_3_ * j1 ^ this.worldObj.getSeed()); | |
boolean flag = false; | |
ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(p_73153_2_, p_73153_3_); | |
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag)); | |
if (this.settings.useMineShafts && this.mapFeaturesEnabled) | |
{ | |
this.mineshaftGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair); | |
} | |
if (this.settings.useVillages && this.mapFeaturesEnabled) | |
{ | |
flag = this.villageGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair); | |
} | |
if (this.settings.useStrongholds && this.mapFeaturesEnabled) | |
{ | |
this.strongholdGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair); | |
} | |
if (this.settings.useTemples && this.mapFeaturesEnabled) | |
{ | |
this.scatteredFeatureGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair); | |
} | |
if (this.settings.useMonuments && this.mapFeaturesEnabled) | |
{ | |
this.oceanMonumentGenerator.func_175794_a(this.worldObj, this.rand, chunkcoordintpair); | |
} | |
int k1; | |
int l1; | |
int i2; | |
if (biomegenbase != BiomeGenBase.desert && biomegenbase != BiomeGenBase.desertHills && this.settings.useWaterLakes && !flag && this.rand.nextInt(this.settings.waterLakeChance) == 0 | |
&& TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAKE)) | |
{ | |
k1 = this.rand.nextInt(16) + 8; | |
l1 = this.rand.nextInt(256); | |
i2 = this.rand.nextInt(16) + 8; | |
(new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, blockpos.add(k1, l1, i2)); | |
} | |
if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, LAVA) && !flag && this.rand.nextInt(this.settings.lavaLakeChance / 10) == 0 && this.settings.useLavaLakes) | |
{ | |
k1 = this.rand.nextInt(16) + 8; | |
l1 = this.rand.nextInt(this.rand.nextInt(248) + 8); | |
i2 = this.rand.nextInt(16) + 8; | |
if (l1 < 63 || this.rand.nextInt(this.settings.lavaLakeChance / 8) == 0) | |
{ | |
(new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, blockpos.add(k1, l1, i2)); | |
} | |
} | |
if (this.settings.useDungeons) | |
{ | |
boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, DUNGEON); | |
for (k1 = 0; doGen && k1 < this.settings.dungeonChance; ++k1) | |
{ | |
l1 = this.rand.nextInt(16) + 8; | |
i2 = this.rand.nextInt(256); | |
int j2 = this.rand.nextInt(16) + 8; | |
(new WorldGenDungeons()).generate(this.worldObj, this.rand, blockpos.add(l1, i2, j2)); | |
} | |
} | |
biomegenbase.decorate(this.worldObj, this.rand, new BlockPos(k, 0, l)); | |
if (TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ANIMALS)) | |
{ | |
SpawnerAnimals.performWorldGenSpawning(this.worldObj, biomegenbase, k + 8, l + 8, 16, 16, this.rand); | |
} | |
blockpos = blockpos.add(8, 0, 8); | |
boolean doGen = TerrainGen.populate(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag, ICE); | |
for (k1 = 0; doGen && k1 < 16; ++k1) | |
{ | |
for (l1 = 0; l1 < 16; ++l1) | |
{ | |
BlockPos blockpos1 = this.worldObj.getPrecipitationHeight(blockpos.add(k1, 0, l1)); | |
BlockPos blockpos2 = blockpos1.down(); | |
if (this.worldObj.func_175675_v(blockpos2)) | |
{ | |
this.worldObj.setBlockState(blockpos2, Blocks.ice.getDefaultState(), 2); | |
} | |
if (this.worldObj.canSnowAt(blockpos1, true)) | |
{ | |
this.worldObj.setBlockState(blockpos1, Blocks.snow_layer.getDefaultState(), 2); | |
} | |
} | |
} | |
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(p_73153_1_, worldObj, rand, p_73153_2_, p_73153_3_, flag)); | |
BlockFalling.fallInstantly = false; | |
} | |
public boolean func_177460_a(IChunkProvider p_177460_1_, Chunk p_177460_2_, int p_177460_3_, int p_177460_4_) | |
{ | |
boolean flag = false; | |
if (this.settings.useMonuments && this.mapFeaturesEnabled && p_177460_2_.getInhabitedTime() < 3600L) | |
{ | |
flag |= this.oceanMonumentGenerator.func_175794_a(this.worldObj, this.rand, new ChunkCoordIntPair(p_177460_3_, p_177460_4_)); | |
} | |
return flag; | |
} | |
/** | |
* Two modes of operation: if passed true, save all Chunks in one go. If passed false, save up to two chunks. | |
* Return true if all chunks have been saved. | |
*/ | |
public boolean saveChunks(boolean p_73151_1_, IProgressUpdate p_73151_2_) | |
{ | |
return true; | |
} | |
/** | |
* Save extra data not associated with any Chunk. Not saved during autosave, only during world unload. Currently | |
* unimplemented. | |
*/ | |
public void saveExtraData() {} | |
/** | |
* Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk. | |
*/ | |
public boolean unloadQueuedChunks() | |
{ | |
return false; | |
} | |
/** | |
* Returns if the IChunkProvider supports saving. | |
*/ | |
public boolean canSave() | |
{ | |
return true; | |
} | |
/** | |
* Converts the instance data to a readable string. | |
*/ | |
public String makeString() | |
{ | |
return "RandomLevelSource"; | |
} | |
public List func_177458_a(EnumCreatureType p_177458_1_, BlockPos p_177458_2_) | |
{ | |
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(p_177458_2_); | |
if (this.mapFeaturesEnabled) | |
{ | |
if (p_177458_1_ == EnumCreatureType.MONSTER && this.scatteredFeatureGenerator.func_175798_a(p_177458_2_)) | |
{ | |
return this.scatteredFeatureGenerator.getScatteredFeatureSpawnList(); | |
} | |
if (p_177458_1_ == EnumCreatureType.MONSTER && this.settings.useMonuments && this.oceanMonumentGenerator.func_175796_a(this.worldObj, p_177458_2_)) | |
{ | |
return this.oceanMonumentGenerator.func_175799_b(); | |
} | |
} | |
return biomegenbase.getSpawnableList(p_177458_1_); | |
} | |
public BlockPos getStrongholdGen(World worldIn, String p_180513_2_, BlockPos p_180513_3_) | |
{ | |
return "Stronghold".equals(p_180513_2_) && this.strongholdGenerator != null ? this.strongholdGenerator.getClosestStrongholdPos(worldIn, p_180513_3_) : null; | |
} | |
public int getLoadedChunkCount() | |
{ | |
return 0; | |
} | |
public void recreateStructures(Chunk p_180514_1_, int p_180514_2_, int p_180514_3_) | |
{ | |
if (this.settings.useMineShafts && this.mapFeaturesEnabled) | |
{ | |
this.mineshaftGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null); | |
} | |
if (this.settings.useVillages && this.mapFeaturesEnabled) | |
{ | |
this.villageGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null); | |
} | |
if (this.settings.useStrongholds && this.mapFeaturesEnabled) | |
{ | |
this.strongholdGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null); | |
} | |
if (this.settings.useTemples && this.mapFeaturesEnabled) | |
{ | |
this.scatteredFeatureGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null); | |
} | |
if (this.settings.useMonuments && this.mapFeaturesEnabled) | |
{ | |
this.oceanMonumentGenerator.func_175792_a(this, this.worldObj, p_180514_2_, p_180514_3_, (ChunkPrimer)null); | |
} | |
} | |
public Chunk provideChunk(BlockPos blockPosIn) | |
{ | |
return this.provideChunk(blockPosIn.getX() >> 4, blockPosIn.getZ() >> 4); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment