-
-
Save DonyorM/47f62eda0add86e828f0 to your computer and use it in GitHub Desktop.
Ender Mod dimension code for multi-biomes
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 mods.ender.main.biome; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.BIG_SHROOM; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.CACTUS; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.CLAY; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.DEAD_BUSH; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.FLOWERS; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.GRASS; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.LAKE; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.LILYPAD; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.PUMPKIN; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.REED; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.SAND; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.SAND_PASS2; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.SHROOM; | |
import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.TREE; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.COAL; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.DIAMOND; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.DIRT; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.GOLD; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.GRAVEL; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.IRON; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.LAPIS; | |
import static net.minecraftforge.event.terraingen.OreGenEvent.GenerateMinable.EventType.REDSTONE; | |
import java.util.Random; | |
import net.minecraft.block.Block; | |
import net.minecraft.world.World; | |
import net.minecraft.world.biome.BiomeDecorator; | |
import net.minecraft.world.biome.BiomeGenBase; | |
import net.minecraft.world.gen.feature.WorldGenBigMushroom; | |
import net.minecraft.world.gen.feature.WorldGenCactus; | |
import net.minecraft.world.gen.feature.WorldGenClay; | |
import net.minecraft.world.gen.feature.WorldGenDeadBush; | |
import net.minecraft.world.gen.feature.WorldGenFlowers; | |
import net.minecraft.world.gen.feature.WorldGenLiquids; | |
import net.minecraft.world.gen.feature.WorldGenMinable; | |
import net.minecraft.world.gen.feature.WorldGenPumpkin; | |
import net.minecraft.world.gen.feature.WorldGenReed; | |
import net.minecraft.world.gen.feature.WorldGenSand; | |
import net.minecraft.world.gen.feature.WorldGenWaterlily; | |
import net.minecraft.world.gen.feature.WorldGenerator; | |
import net.minecraftforge.common.MinecraftForge; | |
import net.minecraftforge.event.terraingen.DecorateBiomeEvent; | |
import net.minecraftforge.event.terraingen.OreGenEvent; | |
import net.minecraftforge.event.terraingen.TerrainGen; | |
public class BiomeEnderDecorator extends BiomeDecorator | |
{ | |
/** The world the BiomeDecorator is currently decorating */ | |
public World currentWorld; | |
/** The Biome Decorator's random number generator. */ | |
public Random randomGenerator; | |
/** The X-coordinate of the chunk currently being decorated */ | |
public int chunk_X; | |
/** The Z-coordinate of the chunk currently being decorated */ | |
public int chunk_Z; | |
/** The biome generator object. */ | |
public BiomeGenBase biome; | |
/** The clay generator. */ | |
public WorldGenerator clayGen = new WorldGenClay(4); | |
/** The sand generator. */ | |
public WorldGenerator sandGen; | |
/** The gravel generator. */ | |
public WorldGenerator gravelAsSandGen; | |
/** The dirt generator. */ | |
public WorldGenerator dirtGen; | |
public WorldGenerator gravelGen; | |
public WorldGenerator coalGen; | |
public WorldGenerator ironGen; | |
/** Field that holds gold WorldGenMinable */ | |
public WorldGenerator goldGen; | |
/** Field that holds redstone WorldGenMinable */ | |
public WorldGenerator redstoneGen; | |
/** Field that holds diamond WorldGenMinable */ | |
public WorldGenerator diamondGen; | |
/** Field that holds Lapis WorldGenMinable */ | |
public WorldGenerator lapisGen; | |
/** Field that holds one of the plantYellow WorldGenFlowers */ | |
public WorldGenerator plantYellowGen; | |
/** Field that holds one of the plantRed WorldGenFlowers */ | |
public WorldGenerator plantRedGen; | |
/** Field that holds mushroomBrown WorldGenFlowers */ | |
public WorldGenerator mushroomBrownGen; | |
/** Field that holds mushroomRed WorldGenFlowers */ | |
public WorldGenerator mushroomRedGen; | |
/** Field that holds big mushroom generator */ | |
public WorldGenerator bigMushroomGen; | |
/** Field that holds WorldGenReed */ | |
public WorldGenerator reedGen; | |
/** Field that holds WorldGenCactus */ | |
public WorldGenerator cactusGen; | |
/** The water lily generation! */ | |
public WorldGenerator waterlilyGen; | |
/** Amount of waterlilys per chunk. */ | |
public int waterlilyPerChunk; | |
/** | |
* The number of trees to attempt to generate per chunk. Up to 10 in forests, none in deserts. | |
*/ | |
public int treesPerChunk; | |
/** | |
* The number of yellow flower patches to generate per chunk. The game generates much less than this number, since | |
* it attempts to generate them at a random altitude. | |
*/ | |
public int flowersPerChunk; | |
/** The amount of tall grass to generate per chunk. */ | |
public int grassPerChunk; | |
/** | |
* The number of dead bushes to generate per chunk. Used in deserts and swamps. | |
*/ | |
public int deadBushPerChunk; | |
/** | |
* The number of extra mushroom patches per chunk. It generates 1/4 this number in brown mushroom patches, and 1/8 | |
* this number in red mushroom patches. These mushrooms go beyond the default base number of mushrooms. | |
*/ | |
public int mushroomsPerChunk; | |
/** | |
* The number of reeds to generate per chunk. Reeds won't generate if the randomly selected placement is unsuitable. | |
*/ | |
public int reedsPerChunk; | |
/** | |
* The number of cactus plants to generate per chunk. Cacti only work on sand. | |
*/ | |
public int cactiPerChunk; | |
/** | |
* The number of sand patches to generate per chunk. Sand patches only generate when part of it is underwater. | |
*/ | |
public int sandPerChunk; | |
/** | |
* The number of sand patches to generate per chunk. Sand patches only generate when part of it is underwater. There | |
* appear to be two separate fields for this. | |
*/ | |
public int sandPerChunk2; | |
/** | |
* The number of clay patches to generate per chunk. Only generates when part of it is underwater. | |
*/ | |
public int clayPerChunk; | |
/** Amount of big mushrooms per chunk */ | |
public int bigMushroomsPerChunk; | |
/** True if decorator should generate surface lava & water */ | |
public boolean generateLakes; | |
public BiomeEnderDecorator(BiomeGenBase par1BiomeGenBase) | |
{ | |
super (par1BiomeGenBase); | |
this.sandGen = new WorldGenSand(7, Block.sand.blockID); | |
this.gravelAsSandGen = new WorldGenSand(6, Block.gravel.blockID); | |
this.dirtGen = new WorldGenMinable(Block.dirt.blockID, 32); | |
this.gravelGen = new WorldGenMinable(Block.gravel.blockID, 32); | |
this.coalGen = new WorldGenMinable(Block.oreCoal.blockID, 16); | |
this.ironGen = new WorldGenMinable(Block.oreIron.blockID, 8); | |
this.goldGen = new WorldGenMinable(Block.oreGold.blockID, 8); | |
this.redstoneGen = new WorldGenMinable(Block.oreRedstone.blockID, 7); | |
this.diamondGen = new WorldGenMinable(Block.oreDiamond.blockID, 7); | |
this.lapisGen = new WorldGenMinable(Block.oreLapis.blockID, 6); | |
this.plantYellowGen = new WorldGenFlowers(Block.plantYellow.blockID); | |
this.plantRedGen = new WorldGenFlowers(Block.plantRed.blockID); | |
this.mushroomBrownGen = new WorldGenFlowers(Block.mushroomBrown.blockID); | |
this.mushroomRedGen = new WorldGenFlowers(Block.mushroomRed.blockID); | |
this.bigMushroomGen = new WorldGenBigMushroom(); | |
this.reedGen = new WorldGenReed(); | |
this.cactusGen = new WorldGenCactus(); | |
this.waterlilyGen = new WorldGenWaterlily(); | |
this.flowersPerChunk = 2; | |
this.grassPerChunk = 1; | |
this.sandPerChunk = 1; | |
this.sandPerChunk2 = 3; | |
this.clayPerChunk = 1; | |
this.generateLakes = true; | |
this.biome = par1BiomeGenBase; | |
} | |
/** | |
* Decorates the world. Calls code that was formerly (pre-1.8) in ChunkProviderGenerate.populate | |
*/ | |
public void decorate(World par1World, Random par2Random, int par3, int par4) | |
{ | |
if (this.currentWorld != null) | |
{ | |
throw new RuntimeException("Already decorating!!"); | |
} | |
else | |
{ | |
this.currentWorld = par1World; | |
this.randomGenerator = par2Random; | |
this.chunk_X = par3; | |
this.chunk_Z = par4; | |
this.decorate(); | |
this.currentWorld = null; | |
this.randomGenerator = null; | |
} | |
} | |
/** | |
* The method that does the work of actually decorating chunks | |
*/ | |
protected void decorate() | |
{ | |
MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(currentWorld, randomGenerator, chunk_X, chunk_Z)); | |
} | |
/** | |
* Standard ore generation helper. Generates most ores. | |
*/ | |
protected void genStandardOre1(int par1, WorldGenerator par2WorldGenerator, int par3, int par4) | |
{ | |
for (int l = 0; l < par1; ++l) | |
{ | |
int i1 = this.chunk_X + this.randomGenerator.nextInt(16); | |
int j1 = this.randomGenerator.nextInt(par4 - par3) + par3; | |
int k1 = this.chunk_Z + this.randomGenerator.nextInt(16); | |
par2WorldGenerator.generate(this.currentWorld, this.randomGenerator, i1, j1, k1); | |
} | |
} | |
/** | |
* Standard ore generation helper. Generates Lapis Lazuli. | |
*/ | |
protected void genStandardOre2(int par1, WorldGenerator par2WorldGenerator, int par3, int par4) | |
{ | |
for (int l = 0; l < par1; ++l) | |
{ | |
int i1 = this.chunk_X + this.randomGenerator.nextInt(16); | |
int j1 = this.randomGenerator.nextInt(par4) + this.randomGenerator.nextInt(par4) + (par3 - par4); | |
int k1 = this.chunk_Z + this.randomGenerator.nextInt(16); | |
par2WorldGenerator.generate(this.currentWorld, this.randomGenerator, i1, j1, k1); | |
} | |
} | |
/** | |
* Generates ores in the current chunk | |
*/ | |
protected void generateOres() | |
{ | |
MinecraftForge.ORE_GEN_BUS.post(new OreGenEvent.Pre(currentWorld, randomGenerator, chunk_X, chunk_Z)); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, dirtGen, chunk_X, chunk_Z, DIRT)) | |
this.genStandardOre1(20, this.dirtGen, 0, 128); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, gravelGen, chunk_X, chunk_Z, GRAVEL)) | |
this.genStandardOre1(10, this.gravelGen, 0, 128); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, coalGen, chunk_X, chunk_Z, COAL)) | |
this.genStandardOre1(20, this.coalGen, 0, 128); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, ironGen, chunk_X, chunk_Z, IRON)) | |
this.genStandardOre1(20, this.ironGen, 0, 64); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, goldGen, chunk_X, chunk_Z, GOLD)) | |
this.genStandardOre1(2, this.goldGen, 0, 32); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, redstoneGen, chunk_X, chunk_Z, REDSTONE)) | |
this.genStandardOre1(8, this.redstoneGen, 0, 16); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, diamondGen, chunk_X, chunk_Z, DIAMOND)) | |
this.genStandardOre1(1, this.diamondGen, 0, 16); | |
if (TerrainGen.generateOre(currentWorld, randomGenerator, lapisGen, chunk_X, chunk_Z, LAPIS)) | |
this.genStandardOre2(1, this.lapisGen, 16, 16); | |
MinecraftForge.ORE_GEN_BUS.post(new OreGenEvent.Post(currentWorld, randomGenerator, chunk_X, chunk_Z)); | |
} | |
} |
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 mods.ender.main.biome; | |
import java.util.Random; | |
import net.minecraft.block.Block; | |
import net.minecraft.entity.monster.EntityEnderman; | |
import net.minecraft.world.World; | |
import net.minecraft.world.biome.BiomeGenBase; | |
import net.minecraft.world.biome.SpawnListEntry; | |
public class BiomeGenEndStonePlains extends BiomeGenBase { | |
public BiomeGenEndStonePlains(int par1) { | |
super(par1); | |
this.spawnableMonsterList.clear(); | |
this.spawnableCreatureList.clear(); | |
this.spawnableWaterCreatureList.clear(); | |
this.spawnableCaveCreatureList.clear(); | |
this.spawnableMonsterList.add(new SpawnListEntry(EntityEnderman.class, 10, 4, 4)); | |
this.topBlock = ((byte)Block.whiteStone.blockID); | |
this.fillerBlock = ((byte)Block.whiteStone.blockID); | |
this.theBiomeDecorator = new BiomeEnderDecorator(this); | |
} | |
public int getSkyColorByTemp(float par1) | |
{ | |
return 0; | |
} | |
} |
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 mods.ender.main.dimension; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.MINESHAFT; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.RAVINE; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.SCATTERED_FEATURE; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.STRONGHOLD; | |
import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.VILLAGE; | |
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON; | |
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE; | |
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE; | |
import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAVA; | |
import java.util.List; | |
import java.util.Random; | |
import net.minecraft.block.Block; | |
import net.minecraft.block.BlockSand; | |
import net.minecraft.entity.EnumCreatureType; | |
import net.minecraft.util.IProgressUpdate; | |
import net.minecraft.util.MathHelper; | |
import net.minecraft.world.ChunkPosition; | |
import net.minecraft.world.SpawnerAnimals; | |
import net.minecraft.world.World; | |
import net.minecraft.world.biome.BiomeGenBase; | |
import net.minecraft.world.chunk.Chunk; | |
import net.minecraft.world.chunk.IChunkProvider; | |
import net.minecraft.world.gen.MapGenBase; | |
import net.minecraft.world.gen.MapGenCaves; | |
import net.minecraft.world.gen.MapGenRavine; | |
import net.minecraft.world.gen.NoiseGeneratorOctaves; | |
import net.minecraft.world.gen.feature.MapGenScatteredFeature; | |
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.MapGenStronghold; | |
import net.minecraft.world.gen.structure.MapGenVillage; | |
import net.minecraftforge.common.MinecraftForge; | |
import net.minecraftforge.event.Event.Result; | |
import net.minecraftforge.event.terraingen.ChunkProviderEvent; | |
import net.minecraftforge.event.terraingen.PopulateChunkEvent; | |
import net.minecraftforge.event.terraingen.TerrainGen; | |
public class ChunkProviderEnder implements IChunkProvider { | |
/** RNG. */ | |
private Random rand; | |
/** A NoiseGeneratorOctaves used in generating terrain */ | |
private NoiseGeneratorOctaves noiseGen1; | |
/** A NoiseGeneratorOctaves used in generating terrain */ | |
private NoiseGeneratorOctaves noiseGen2; | |
/** A NoiseGeneratorOctaves used in generating terrain */ | |
private NoiseGeneratorOctaves noiseGen3; | |
/** A NoiseGeneratorOctaves used in generating terrain */ | |
private NoiseGeneratorOctaves noiseGen4; | |
/** 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; | |
/** Holds the overall noise array used in chunk generation */ | |
private double[] noiseArray; | |
private double[] stoneNoise = new double[256]; | |
private MapGenBase caveGenerator = new MapGenCaves(); | |
/** Holds Stronghold Generator */ | |
private MapGenStronghold strongholdGenerator = new MapGenStronghold(); | |
/** Holds Village Generator */ | |
private MapGenVillage villageGenerator = new MapGenVillage(); | |
/** Holds Mineshaft Generator */ | |
private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft(); | |
private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature(); | |
/** Holds ravine generator */ | |
private MapGenBase ravineGenerator = new MapGenRavine(); | |
/** The biomes that are used to generate the chunk */ | |
private BiomeGenBase[] biomesForGeneration; | |
/** A double array that hold terrain noise from noiseGen3 */ | |
double[] noise3; | |
/** A double array that hold terrain noise */ | |
double[] noise1; | |
/** A double array that hold terrain noise from noiseGen2 */ | |
double[] noise2; | |
/** A double array that hold terrain noise from noiseGen5 */ | |
double[] noise5; | |
/** A double array that holds terrain noise from noiseGen6 */ | |
double[] noise6; | |
/** | |
* Used to store the 5x5 parabolic field that is used during terrain | |
* generation. | |
*/ | |
float[] parabolicField; | |
int[][] field_73219_j = new int[32][32]; | |
{ | |
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); | |
} | |
public ChunkProviderEnder(World world, long seed, boolean mapFeaturesEnabled) { | |
this.worldObj = world; | |
this.mapFeaturesEnabled = mapFeaturesEnabled; | |
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.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4); | |
this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10); | |
this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16); | |
this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8); | |
NoiseGeneratorOctaves[] noiseGens = { noiseGen1, noiseGen2, noiseGen3, noiseGen4, noiseGen5, noiseGen6, mobSpawnerNoise }; | |
noiseGens = TerrainGen.getModdedNoiseGenerators(world, this.rand, noiseGens); | |
this.noiseGen1 = noiseGens[0]; | |
this.noiseGen2 = noiseGens[1]; | |
this.noiseGen3 = noiseGens[2]; | |
this.noiseGen4 = noiseGens[3]; | |
this.noiseGen5 = noiseGens[4]; | |
this.noiseGen6 = noiseGens[5]; | |
this.mobSpawnerNoise = noiseGens[6]; | |
} | |
/** | |
* Generates the shape of the terrain for the chunk though its all stone | |
* though the water is frozen if the temperature is low enough | |
*/ | |
public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte) { | |
byte b0 = 4; | |
byte b1 = 16; | |
byte b2 = 63; | |
int k = b0 + 1; | |
byte b3 = 17; | |
int l = b0 + 1; | |
this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, k + 5, l + 5); | |
this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * b0, 0, par2 * b0, k, b3, l); | |
for (int i1 = 0; i1 < b0; ++i1) { | |
for (int j1 = 0; j1 < b0; ++j1) { | |
for (int k1 = 0; k1 < b1; ++k1) { | |
double d0 = 0.125D; | |
double d1 = this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 0]; | |
double d2 = this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 0]; | |
double d3 = this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 0]; | |
double d4 = this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 0]; | |
double d5 = (this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 1] - d1) * d0; | |
double d6 = (this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 1] - d2) * d0; | |
double d7 = (this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 1] - d3) * d0; | |
double d8 = (this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 1] - d4) * d0; | |
for (int l1 = 0; l1 < 8; ++l1) { | |
double d9 = 0.25D; | |
double d10 = d1; | |
double d11 = d2; | |
double d12 = (d3 - d1) * d9; | |
double d13 = (d4 - d2) * d9; | |
for (int i2 = 0; i2 < 4; ++i2) { | |
int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1; | |
short short1 = 128; | |
j2 -= short1; | |
double d14 = 0.25D; | |
double d15 = (d11 - d10) * d14; | |
double d16 = d10 - d15; | |
for (int k2 = 0; k2 < 4; ++k2) { | |
if ((d16 += d15) > 0.0D) { | |
par3ArrayOfByte[j2 += short1] = (byte) Block.stone.blockID;//Block.stone.blockID; | |
} else if (k1 * 8 + l1 < b2) { | |
par3ArrayOfByte[j2 += short1] = (byte) Block.waterStill.blockID; | |
} else { | |
par3ArrayOfByte[j2 += short1] = 0; | |
} | |
} | |
d10 += d12; | |
d11 += d13; | |
} | |
d1 += d5; | |
d2 += d6; | |
d3 += d7; | |
d4 += d8; | |
} | |
} | |
} | |
} | |
} | |
/** | |
* Replaces the stone that was placed in with blocks that match the biome | |
*/ | |
public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase) { | |
ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, par4ArrayOfBiomeGenBase); | |
MinecraftForge.EVENT_BUS.post(event); | |
if (event.getResult() == Result.DENY) | |
return; | |
byte b0 = 63; | |
double d0 = 0.03125D; | |
this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D, d0 * 2.0D); | |
for (int k = 0; k < 16; ++k) { | |
for (int l = 0; l < 16; ++l) { | |
BiomeGenBase biomegenbase = par4ArrayOfBiomeGenBase[l + k * 16]; | |
float f = biomegenbase.getFloatTemperature(); | |
int i1 = (int) (this.stoneNoise[k + l * 16] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D); | |
int j1 = -1; | |
byte b1 = biomegenbase.topBlock; | |
byte b2 = biomegenbase.fillerBlock; | |
for (int k1 = 127; k1 >= 0; --k1) { | |
int l1 = (l * 16 + k) * 128 + k1; | |
if (k1 <= 0 + this.rand.nextInt(5)) { | |
par3ArrayOfByte[l1] = (byte) Block.bedrock.blockID; | |
} else { | |
byte b3 = par3ArrayOfByte[l1]; | |
if (b3 == 0) { | |
j1 = -1; | |
} else if (b3 == Block.stone.blockID) { | |
if (j1 == -1) { | |
if (i1 <= 0) { | |
b1 = 0; | |
b2 = (byte) Block.dirt.blockID;//was dirt | |
} else if (k1 >= b0 - 4 && k1 <= b0 + 1) { | |
b1 = biomegenbase.topBlock; | |
b2 = biomegenbase.fillerBlock; | |
} | |
if (k1 < b0 && b1 == 0) { | |
if (f < 0.15F) { | |
b1 = (byte) Block.ice.blockID; | |
} else { | |
b1 = (byte) Block.waterStill.blockID; | |
} | |
} | |
j1 = i1; | |
if (k1 >= b0 - 1) { | |
par3ArrayOfByte[l1] = b1; | |
} else { | |
par3ArrayOfByte[l1] = b2; | |
} | |
} else if (j1 > 0) { | |
--j1; | |
par3ArrayOfByte[l1] = b2; | |
if (j1 == 0 && b2 == Block.sand.blockID) { | |
j1 = this.rand.nextInt(4); | |
b2 = (byte) Block.sandStone.blockID; | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
} | |
/** | |
* loads or generates the chunk at the chunk location specified | |
*/ | |
public Chunk loadChunk(int par1, int par2) { | |
return this.provideChunk(par1, par2); | |
} | |
/** | |
* 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 par1, int par2) { | |
this.rand.setSeed((long) par1 * 341873128712L + (long) par2 * 132897987541L); | |
byte[] abyte = new byte[32768]; | |
this.generateTerrain(par1, par2, abyte); | |
this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16); | |
this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration); | |
this.caveGenerator.generate(this, this.worldObj, par1, par2, abyte); | |
this.ravineGenerator.generate(this, this.worldObj, par1, par2, abyte); | |
if (this.mapFeaturesEnabled) { | |
this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, abyte); | |
this.villageGenerator.generate(this, this.worldObj, par1, par2, abyte); | |
this.strongholdGenerator.generate(this, this.worldObj, par1, par2, abyte); | |
this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, abyte); | |
} | |
Chunk chunk = new Chunk(this.worldObj, 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; | |
} | |
/** | |
* generates a subset of the level's terrain data. Takes 7 arguments: the | |
* [empty] noise array, the position, and the size. | |
*/ | |
private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7) { | |
ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7); | |
MinecraftForge.EVENT_BUS.post(event); | |
if (event.getResult() == Result.DENY) | |
return event.noisefield; | |
if (par1ArrayOfDouble == null) { | |
par1ArrayOfDouble = new double[par5 * par6 * par7]; | |
} | |
if (this.parabolicField == null) { | |
this.parabolicField = new float[25]; | |
for (int k1 = -2; k1 <= 2; ++k1) { | |
for (int l1 = -2; l1 <= 2; ++l1) { | |
float f = 10.0F / MathHelper.sqrt_float((float) (k1 * k1 + l1 * l1) + 0.2F); | |
this.parabolicField[k1 + 2 + (l1 + 2) * 5] = f; | |
} | |
} | |
} | |
double d0 = 684.412D; | |
double d1 = 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, d0 / 80.0D, d1 / 160.0D, d0 / 80.0D); | |
this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, d0, d1, d0); | |
this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, d0, d1, d0); | |
boolean flag = false; | |
boolean flag1 = false; | |
int i2 = 0; | |
int j2 = 0; | |
for (int k2 = 0; k2 < par5; ++k2) { | |
for (int l2 = 0; l2 < par7; ++l2) { | |
float f1 = 0.0F; | |
float f2 = 0.0F; | |
float f3 = 0.0F; | |
byte b0 = 2; | |
BiomeGenBase biomegenbase = this.biomesForGeneration[k2 + 2 + (l2 + 2) * (par5 + 5)]; | |
for (int i3 = -b0; i3 <= b0; ++i3) { | |
for (int j3 = -b0; j3 <= b0; ++j3) { | |
BiomeGenBase biomegenbase1 = this.biomesForGeneration[k2 + i3 + 2 + (l2 + j3 + 2) * (par5 + 5)]; | |
float f4 = this.parabolicField[i3 + 2 + (j3 + 2) * 5] / (biomegenbase1.minHeight + 2.0F); | |
if (biomegenbase1.minHeight > biomegenbase.minHeight) { | |
f4 /= 2.0F; | |
} | |
f1 += biomegenbase1.maxHeight * f4; | |
f2 += biomegenbase1.minHeight * f4; | |
f3 += f4; | |
} | |
} | |
f1 /= f3; | |
f2 /= f3; | |
f1 = f1 * 0.9F + 0.1F; | |
f2 = (f2 * 4.0F - 1.0F) / 8.0F; | |
double d2 = this.noise6[j2] / 8000.0D; | |
if (d2 < 0.0D) { | |
d2 = -d2 * 0.3D; | |
} | |
d2 = d2 * 3.0D - 2.0D; | |
if (d2 < 0.0D) { | |
d2 /= 2.0D; | |
if (d2 < -1.0D) { | |
d2 = -1.0D; | |
} | |
d2 /= 1.4D; | |
d2 /= 2.0D; | |
} else { | |
if (d2 > 1.0D) { | |
d2 = 1.0D; | |
} | |
d2 /= 8.0D; | |
} | |
++j2; | |
for (int k3 = 0; k3 < par6; ++k3) { | |
double d3 = (double) f2; | |
double d4 = (double) f1; | |
d3 += d2 * 0.2D; | |
d3 = d3 * (double) par6 / 16.0D; | |
double d5 = (double) par6 / 2.0D + d3 * 4.0D; | |
double d6 = 0.0D; | |
double d7 = ((double) k3 - d5) * 12.0D * 128.0D / 128.0D / d4; | |
if (d7 < 0.0D) { | |
d7 *= 4.0D; | |
} | |
double d8 = this.noise1[i2] / 512.0D; | |
double d9 = this.noise2[i2] / 512.0D; | |
double d10 = (this.noise3[i2] / 10.0D + 1.0D) / 2.0D; | |
if (d10 < 0.0D) { | |
d6 = d8; | |
} else if (d10 > 1.0D) { | |
d6 = d9; | |
} else { | |
d6 = d8 + (d9 - d8) * d10; | |
} | |
d6 -= d7; | |
if (k3 > par6 - 4) { | |
double d11 = (double) ((float) (k3 - (par6 - 4)) / 3.0F); | |
d6 = d6 * (1.0D - d11) + -10.0D * d11; | |
} | |
par1ArrayOfDouble[i2] = d6; | |
++i2; | |
} | |
} | |
} | |
return par1ArrayOfDouble; | |
} | |
/** | |
* Checks to see if a chunk exists at x, y | |
*/ | |
public boolean chunkExists(int par1, int par2) { | |
return true; | |
} | |
/** | |
* Populates chunk with ores etc etc | |
*/ | |
public void populate(IChunkProvider par1IChunkProvider, int par2, int par3) { | |
BlockSand.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; | |
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, rand, par2, par3, flag)); | |
if (this.mapFeaturesEnabled) { | |
this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); | |
flag = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); | |
this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); | |
this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3); | |
} | |
int k1; | |
int l1; | |
int i2; | |
if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, LAKE) && !flag && this.rand.nextInt(4) == 0) { | |
k1 = k + this.rand.nextInt(16) + 8; | |
l1 = this.rand.nextInt(128); | |
i2 = l + this.rand.nextInt(16) + 8; | |
(new WorldGenLakes(Block.waterStill.blockID)).generate(this.worldObj, this.rand, k1, l1, i2); | |
} | |
if (TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, LAVA) && !flag && this.rand.nextInt(8) == 0) { | |
k1 = k + this.rand.nextInt(16) + 8; | |
l1 = this.rand.nextInt(this.rand.nextInt(120) + 8); | |
i2 = l + this.rand.nextInt(16) + 8; | |
if (l1 < 63 || this.rand.nextInt(10) == 0) { | |
(new WorldGenLakes(Block.lavaStill.blockID)).generate(this.worldObj, this.rand, k1, l1, i2); | |
} | |
} | |
boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, rand, par2, par3, flag, DUNGEON); | |
for (k1 = 0; doGen && k1 < 8; ++k1) { | |
l1 = k + this.rand.nextInt(16) + 8; | |
i2 = this.rand.nextInt(128); | |
int j2 = l + this.rand.nextInt(16) + 8; | |
if ((new WorldGenDungeons()).generate(this.worldObj, this.rand, l1, i2, j2)) { | |
; | |
} | |
} | |
MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, rand, par2, par3, flag)); | |
BlockSand.fallInstantly = false; | |
} | |
/** | |
* 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 par1, IProgressUpdate par2IProgressUpdate) { | |
return true; | |
} | |
public void func_104112_b() { | |
} | |
/** | |
* 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"; | |
} | |
/** | |
* Returns a list of creatures of the specified type that can spawn at the | |
* given location. | |
*/ | |
public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4) { | |
BiomeGenBase biomegenbase = this.worldObj.getBiomeGenForCoords(par2, par4); | |
return biomegenbase == null ? null : (biomegenbase == BiomeGenBase.swampland && par1EnumCreatureType == EnumCreatureType.monster && this.scatteredFeatureGenerator.hasStructureAt(par2, par3, par4) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : biomegenbase.getSpawnableList(par1EnumCreatureType)); | |
} | |
/** | |
* Returns the location of the closest structure of the specified type. If | |
* not found returns null. | |
*/ | |
public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5) { | |
return "Stronghold".equals(par2Str) && this.strongholdGenerator != null ? this.strongholdGenerator.getNearestInstance(par1World, par3, par4, par5) : null; | |
} | |
public int getLoadedChunkCount() { | |
return 0; | |
} | |
public void recreateStructures(int par1, int par2) { | |
if (this.mapFeaturesEnabled) { | |
this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, (byte[]) null); | |
this.villageGenerator.generate(this, this.worldObj, par1, par2, (byte[]) null); | |
this.strongholdGenerator.generate(this, this.worldObj, par1, par2, (byte[]) null); | |
this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, (byte[]) null); | |
} | |
} | |
@Override | |
public void saveExtraData() { | |
// TODO Auto-generated method stub | |
} | |
} |
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 mods.ender.main.dimension; | |
import mods.ender.main.Ender; | |
import net.minecraft.world.biome.BiomeGenBase; | |
import net.minecraft.world.gen.layer.GenLayer; | |
import net.minecraft.world.gen.layer.IntCache; | |
public class GenLayerBiomesEnder extends GenLayer { | |
protected BiomeGenBase[] allowedBiomes = {Ender.endStonePlains}; | |
public GenLayerBiomesEnder(long seed, GenLayer genlayer) { | |
super(seed); | |
this.parent = genlayer; | |
} | |
public GenLayerBiomesEnder(long seed) { | |
super(seed); | |
} | |
@Override | |
public int[] getInts(int x, int z, int width, int depth) | |
{ | |
int[] dest = IntCache.getIntCache(width*depth); | |
for (int dz=0; dz<depth; dz++) | |
{ | |
for (int dx=0; dx<width; dx++) | |
{ | |
this.initChunkSeed(dx+x, dz+z); | |
dest[(dx+dz*width)] = this.allowedBiomes[nextInt(this.allowedBiomes.length)].biomeID; | |
} | |
} | |
return dest; | |
} | |
} |
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 mods.ender.main.dimension; | |
import net.minecraft.world.WorldType; | |
import net.minecraft.world.gen.layer.GenLayer; | |
import net.minecraft.world.gen.layer.GenLayerAddIsland; | |
import net.minecraft.world.gen.layer.GenLayerAddMushroomIsland; | |
import net.minecraft.world.gen.layer.GenLayerAddSnow; | |
import net.minecraft.world.gen.layer.GenLayerBiome; | |
import net.minecraft.world.gen.layer.GenLayerFuzzyZoom; | |
import net.minecraft.world.gen.layer.GenLayerHills; | |
import net.minecraft.world.gen.layer.GenLayerIsland; | |
import net.minecraft.world.gen.layer.GenLayerRiver; | |
import net.minecraft.world.gen.layer.GenLayerRiverInit; | |
import net.minecraft.world.gen.layer.GenLayerRiverMix; | |
import net.minecraft.world.gen.layer.GenLayerShore; | |
import net.minecraft.world.gen.layer.GenLayerSmooth; | |
import net.minecraft.world.gen.layer.GenLayerSwampRivers; | |
import net.minecraft.world.gen.layer.GenLayerVoronoiZoom; | |
import net.minecraft.world.gen.layer.GenLayerZoom; | |
import net.minecraftforge.common.MinecraftForge; | |
import net.minecraftforge.event.terraingen.WorldTypeEvent; | |
public abstract class GenLayerEnder extends GenLayer | |
{ | |
public GenLayerEnder(long seed) { | |
super(seed); | |
} | |
public static GenLayer[] makeTheWorld(long seed) { | |
GenLayer biomes = new GenLayerBiomesEnder(1L); | |
// more GenLayerZoom = bigger biomes | |
biomes = new GenLayerZoom(1000L, biomes); | |
biomes = new GenLayerZoom(1001L, biomes); | |
biomes = new GenLayerZoom(1002L, biomes); | |
biomes = new GenLayerZoom(1003L, biomes); | |
biomes = new GenLayerZoom(1004L, biomes); | |
biomes = new GenLayerZoom(1005L, biomes); | |
GenLayer genlayervoronoizoom = new GenLayerVoronoiZoom(10L, biomes); | |
biomes.initWorldGenSeed(seed); | |
genlayervoronoizoom.initWorldGenSeed(seed); | |
return new GenLayer[] {biomes, genlayervoronoizoom}; | |
} | |
} |
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 mods.ender.main.dimension; | |
import java.util.ArrayList; | |
import java.util.List; | |
import java.util.Random; | |
import mods.ender.main.Ender; | |
import net.minecraft.world.ChunkPosition; | |
import net.minecraft.world.World; | |
import net.minecraft.world.WorldType; | |
import net.minecraft.world.biome.BiomeCache; | |
import net.minecraft.world.biome.BiomeGenBase; | |
import net.minecraft.world.biome.WorldChunkManager; | |
import net.minecraft.world.gen.layer.GenLayer; | |
import net.minecraft.world.gen.layer.IntCache; | |
import cpw.mods.fml.relauncher.Side; | |
import cpw.mods.fml.relauncher.SideOnly; | |
public class WorldChunkManagerEnder extends WorldChunkManager | |
{ | |
private GenLayer myGenBiomes; | |
private GenLayer myBiomeIndexLayer; | |
private BiomeCache myBiomeCache; | |
private List<BiomeGenBase> myBiomesToSpawnIn; | |
protected WorldChunkManagerEnder() | |
{ | |
this.myBiomeCache = new BiomeCache(this); | |
this.myBiomesToSpawnIn = new ArrayList<BiomeGenBase>(); | |
this.myBiomesToSpawnIn.add(Ender.endStonePlains); | |
} | |
public WorldChunkManagerEnder(long seed, WorldType worldtype) | |
{ | |
this(); | |
GenLayer[] agenlayer = GenLayerEnder.makeTheWorld(seed); | |
agenlayer = getModdedBiomeGenerators(worldtype, seed, agenlayer); | |
this.myGenBiomes = agenlayer[0]; | |
this.myBiomeIndexLayer = agenlayer[1]; | |
} | |
public WorldChunkManagerEnder(World world) | |
{ | |
this(world.getSeed(), world.provider.terrainType); | |
} | |
/** | |
* Gets the list of valid biomes for the player to spawn in. | |
*/ | |
public List<BiomeGenBase> getBiomesToSpawnIn() | |
{ | |
return this.myBiomesToSpawnIn; | |
} | |
/** | |
* Returns the BiomeGenBase related to the x, z position on the world. | |
*/ | |
public BiomeGenBase getBiomeGenAt(int x, int z) | |
{ | |
BiomeGenBase biome = this.myBiomeCache.getBiomeGenAt(x, z); | |
if (biome == null) | |
{ | |
return Ender.endStonePlains; | |
} | |
return biome; | |
} | |
/** | |
* Returns a list of rainfall values for the specified blocks. Args: | |
* listToReuse, x, z, width, length. | |
*/ | |
public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5) | |
{ | |
IntCache.resetIntCache(); | |
if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5) | |
{ | |
par1ArrayOfFloat = new float[par4 * par5]; | |
} | |
int[] aint = this.myBiomeIndexLayer.getInts(par2, par3, par4, par5); | |
for (int i1 = 0; i1 < par4 * par5; ++i1) | |
{ | |
float f = (float) BiomeGenBase.biomeList[aint[i1]].getIntRainfall() / 65536.0F; | |
if (f > 1.0F) { | |
f = 1.0F; | |
} | |
par1ArrayOfFloat[i1] = f; | |
} | |
return par1ArrayOfFloat; | |
} | |
/** | |
* Return an adjusted version of a given temperature based on the y height | |
*/ | |
@SideOnly(Side.CLIENT) | |
public float getTemperatureAtHeight(float par1, int par2) | |
{ | |
return par1; | |
} | |
/** | |
* Returns a list of temperatures to use for the specified blocks. Args: | |
* listToReuse, x, y, width, length | |
*/ | |
public float[] getTemperatures(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5) | |
{ | |
IntCache.resetIntCache(); | |
if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5) | |
{ | |
par1ArrayOfFloat = new float[par4 * par5]; | |
} | |
int[] aint = this.myBiomeIndexLayer.getInts(par2, par3, par4, par5); | |
for (int i1 = 0; i1 < par4 * par5; ++i1) | |
{ | |
float f = (float) BiomeGenBase.biomeList[aint[i1]].getIntTemperature() / 65536.0F; | |
if (f > 1.0F) { | |
f = 1.0F; | |
} | |
par1ArrayOfFloat[i1] = f; | |
} | |
return par1ArrayOfFloat; | |
} | |
/** | |
* Returns an array of biomes for the location input. | |
*/ | |
public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) { | |
IntCache.resetIntCache(); | |
if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5) { | |
par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5]; | |
} | |
int[] aint = this.myGenBiomes.getInts(par2, par3, par4, par5); | |
for (int i = 0; i < par4 * par5; ++i) { | |
if (aint[i] >= 0) { | |
par1ArrayOfBiomeGenBase[i] = BiomeGenBase.biomeList[aint[i]]; | |
} else { | |
//Change this to a biome | |
par1ArrayOfBiomeGenBase[i] = Ender.endStonePlains; | |
} | |
} | |
return par1ArrayOfBiomeGenBase; | |
} | |
/** | |
* Returns biomes to use for the blocks and loads the other data like | |
* temperature and humidity onto the WorldChunkManager Args: oldBiomeList, | |
* x, z, width, depth | |
*/ | |
public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) { | |
return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true); | |
} | |
/** | |
* Return a list of biomes for the specified blocks. Args: listToReuse, x, | |
* y, width, length, cacheFlag (if false, don't check biomeCache to avoid | |
* infinite loop in BiomeCacheBlock) | |
*/ | |
public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] par1ArrayOfBiomeGenBase, int x, int y, int width, int length, boolean cacheFlag) { | |
IntCache.resetIntCache(); | |
if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < width * length) { | |
par1ArrayOfBiomeGenBase = new BiomeGenBase[width * length]; | |
} | |
if (cacheFlag && width == 16 && length == 16 && (x & 15) == 0 && (y & 15) == 0) { | |
BiomeGenBase[] abiomegenbase1 = this.myBiomeCache.getCachedBiomes(x, y); | |
System.arraycopy(abiomegenbase1, 0, par1ArrayOfBiomeGenBase, 0, width * length); | |
return par1ArrayOfBiomeGenBase; | |
} else { | |
int[] aint = this.myBiomeIndexLayer.getInts(x, y, width, length); | |
for (int i = 0; i < width * length; ++i) { | |
if (aint[i] >= 0) { | |
par1ArrayOfBiomeGenBase[i] = BiomeGenBase.biomeList[aint[i]]; | |
} else { | |
//Change this to a biome | |
par1ArrayOfBiomeGenBase[i] = Ender.endStonePlains; | |
} | |
} | |
return par1ArrayOfBiomeGenBase; | |
} | |
} | |
/** | |
* checks given Chunk's Biomes against List of allowed ones | |
*/ | |
public boolean areBiomesViable(int par1, int par2, int par3, List par4List) { | |
IntCache.resetIntCache(); | |
int l = par1 - par3 >> 2; | |
int i1 = par2 - par3 >> 2; | |
int j1 = par1 + par3 >> 2; | |
int k1 = par2 + par3 >> 2; | |
int l1 = j1 - l + 1; | |
int i2 = k1 - i1 + 1; | |
int[] aint = this.myGenBiomes.getInts(l, i1, l1, i2); | |
for (int j2 = 0; j2 < l1 * i2; ++j2) { | |
BiomeGenBase biomegenbase = BiomeGenBase.biomeList[aint[j2]]; | |
if (!par4List.contains(biomegenbase)) { | |
return false; | |
} | |
} | |
return true; | |
} | |
/** | |
* Finds a valid position within a range, that is in one of the listed | |
* biomes. Searches {par1,par2} +-par3 blocks. Strongly favors positive y | |
* positions. | |
*/ | |
public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random) { | |
IntCache.resetIntCache(); | |
int l = par1 - par3 >> 2; | |
int i1 = par2 - par3 >> 2; | |
int j1 = par1 + par3 >> 2; | |
int k1 = par2 + par3 >> 2; | |
int l1 = j1 - l + 1; | |
int i2 = k1 - i1 + 1; | |
int[] aint = this.myGenBiomes.getInts(l, i1, l1, i2); | |
ChunkPosition chunkposition = null; | |
int j2 = 0; | |
for (int k2 = 0; k2 < l1 * i2; ++k2) { | |
int l2 = l + k2 % l1 << 2; | |
int i3 = i1 + k2 / l1 << 2; | |
BiomeGenBase biomegenbase = BiomeGenBase.biomeList[aint[k2]]; | |
if (par4List.contains(biomegenbase) && (chunkposition == null || par5Random.nextInt(j2 + 1) == 0)) { | |
chunkposition = new ChunkPosition(l2, 0, i3); | |
++j2; | |
} | |
} | |
return chunkposition; | |
} | |
/** | |
* Calls the WorldChunkManager's biomeCache.cleanupCache() | |
*/ | |
public void cleanupCache() | |
{ | |
this.myBiomeCache.cleanupCache(); | |
} | |
} |
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 mods.ender.main.dimension; | |
import mods.ender.main.Ender; | |
import net.minecraft.world.WorldProvider; | |
import net.minecraft.world.biome.BiomeGenBase; | |
import net.minecraft.world.biome.WorldChunkManagerHell; | |
import net.minecraft.world.chunk.IChunkProvider; | |
public class WorldProviderEnder extends WorldProvider { | |
public void registerWorldChunkManager() | |
{ | |
this.worldChunkMgr = new WorldChunkManagerEnder(); | |
this.dimensionId = Ender.dimensionId; | |
} | |
public IChunkProvider createChunkGenerator() | |
{ | |
return new ChunkProviderEnder(worldObj, worldObj.getSeed(), true); | |
} | |
@Override | |
public String getDimensionName() { | |
return "The Ender"; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment