API tools faq
paste
Guest User

ChunkProviderMarona

a guest
May 15th, 2013
132
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 38.11 KB | None | 0 0
raw download clone embed print report
  1. package Mod_Ores.BiomeGen.Dimension;
  2.  
  3. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON;
  4. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.FIRE;
  5. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.GLOWSTONE;
  6. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.NETHER_LAVA;
  7. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE;
  8. import java.util.ArrayList;
  9. import java.util.Arrays;
  10. import java.util.List;
  11. import java.util.Random;
  12.  
  13. import Mod_Ores.mod_Ores;
  14. import Mod_Ores.BiomeGen.WorldGenIceTower;
  15. import Mod_Ores.BiomeGen.WorldGenSoulTemple;
  16. import Mod_Ores.BiomeGen.WorldGen.WorldGenBaneberryVines;
  17. import Mod_Ores.BiomeGen.WorldGen.WorldGenBlackberryVines;
  18. import Mod_Ores.BiomeGen.WorldGen.WorldGenBlueberryVines;
  19. import Mod_Ores.BiomeGen.WorldGen.WorldGenCranberryVines;
  20. import Mod_Ores.BiomeGen.WorldGen.WorldGenGrapeTree;
  21. import Mod_Ores.BiomeGen.WorldGen.WorldGenRaspberryVines;
  22. import Mod_Ores.BiomeGen.WorldGen.WorldGenRazzberryVines;
  23. import Mod_Ores.BiomeGen.WorldGen.WorldGenStrawberryVines;
  24.  
  25. import net.minecraft.block.Block;
  26. import net.minecraft.block.BlockSand;
  27. import net.minecraft.entity.EnumCreatureType;
  28. import net.minecraft.util.IProgressUpdate;
  29. import net.minecraft.world.ChunkPosition;
  30. import net.minecraft.world.World;
  31. import net.minecraft.world.biome.BiomeGenBase;
  32. import net.minecraft.world.chunk.Chunk;
  33. import net.minecraft.world.chunk.IChunkProvider;
  34. import net.minecraft.world.gen.MapGenBase;
  35. import net.minecraft.world.gen.MapGenCavesHell;
  36. import net.minecraft.world.gen.NoiseGeneratorOctaves;
  37. import net.minecraft.world.gen.feature.WorldGenDungeons;
  38. import net.minecraft.world.gen.feature.WorldGenFire;
  39. import net.minecraft.world.gen.feature.WorldGenFlowers;
  40. import net.minecraft.world.gen.feature.WorldGenGlowStone1;
  41. import net.minecraft.world.gen.feature.WorldGenGlowStone2;
  42. import net.minecraft.world.gen.feature.WorldGenHellLava;
  43. import net.minecraft.world.gen.feature.WorldGenLiquids;
  44. import net.minecraft.world.gen.feature.WorldGenMinable;
  45. import net.minecraft.world.gen.structure.MapGenNetherBridge;
  46. import net.minecraftforge.common.MinecraftForge;
  47. import net.minecraftforge.event.Event.Result;
  48. import net.minecraftforge.event.terraingen.ChunkProviderEvent;
  49. import net.minecraftforge.event.terraingen.DecorateBiomeEvent;
  50. import net.minecraftforge.event.terraingen.PopulateChunkEvent;
  51. import static net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.*;
  52. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.*;
  53. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.*;
  54. import net.minecraftforge.event.terraingen.TerrainGen;
  55.  
  56. public class ChunkProviderMarona implements IChunkProvider
  57. {
  58.     //NETHER SOUL FOREST IDEA  
  59.    
  60.     private Random soulRNG;
  61.    
  62.     // Biome list
  63.     public static ArrayList<BiomeGenBase> allowedBiomes = new ArrayList<BiomeGenBase>(Arrays.asList(mod_Ores.SoulForest,mod_Ores.FrostCaves));
  64.      public static ArrayList<BiomeGenBase> disallowedBiomes = new ArrayList<BiomeGenBase>(Arrays.asList(BiomeGenBase.ocean, BiomeGenBase.plains, BiomeGenBase.desert, BiomeGenBase.extremeHills, BiomeGenBase.forest, BiomeGenBase.taiga, BiomeGenBase.swampland, BiomeGenBase.river));
  65.      
  66.     /** A NoiseGeneratorOctaves used in generating nether terrain */
  67.     private NoiseGeneratorOctaves netherNoiseGen1;
  68.     private NoiseGeneratorOctaves netherNoiseGen2;
  69.     private NoiseGeneratorOctaves netherNoiseGen3;
  70.     public NoiseGeneratorOctaves mobSpawnerNoise;
  71.  
  72.     /** Determines whether lateriteGrass or porphyry can be generated at a location */
  73.     private NoiseGeneratorOctaves lateriteGrassPorphyryNoise;
  74.  
  75.     /**
  76.      * Determines whether something other than porphyry can be generated at a location
  77.      */
  78.     private NoiseGeneratorOctaves porphyryExclusivityNoiseGen;
  79.     public NoiseGeneratorOctaves netherNoiseGen6;
  80.     public NoiseGeneratorOctaves netherNoiseGen7;
  81.  
  82.     /** The biomes that are used to generate the chunk */
  83.     private BiomeGenBase[] biomesForGeneration;
  84.    
  85.     /** Is the world that the nether is getting generated. */
  86.     private World worldObj;
  87.     private double[] noiseField;
  88.     public MapGenNetherBridge genNetherBridge = new MapGenNetherBridge();
  89.  
  90.     /**
  91.      * Holds the noise used to determine whether lateriteGrass can be generated at a location
  92.      */
  93.     private double[] lateriteGrassNoise = new double[256];
  94.     private double[] porphyryNoise = new double[256];
  95.  
  96.     /**
  97.      * Holds the noise used to determine whether something other than porphyry can be generated at a location
  98.      */
  99.     private double[] porphyryExclusivityNoise = new double[256];
  100.     private MapGenBase netherCaveGenerator = new MapGenCavesHell();
  101.     double[] noiseData1;
  102.     double[] noiseData2;
  103.     double[] noiseData3;
  104.     double[] noiseData4;
  105.     double[] noiseData5;
  106.  
  107.     private Object theBiomeDecorator;
  108.  
  109.     public ChunkProviderMarona(World par1World, long par2, boolean b)
  110.     {
  111.         this.worldObj = par1World;
  112.         this.soulRNG = new Random(par2);
  113.         this.netherNoiseGen1 = new NoiseGeneratorOctaves(this.soulRNG, 16);
  114.         this.netherNoiseGen2 = new NoiseGeneratorOctaves(this.soulRNG, 16);
  115.         this.netherNoiseGen3 = new NoiseGeneratorOctaves(this.soulRNG, 8);
  116.         this.lateriteGrassPorphyryNoise = new NoiseGeneratorOctaves(this.soulRNG, 4);
  117.         this.porphyryExclusivityNoiseGen = new NoiseGeneratorOctaves(this.soulRNG, 4);
  118.         this.netherNoiseGen6 = new NoiseGeneratorOctaves(this.soulRNG, 10);
  119.         this.netherNoiseGen7 = new NoiseGeneratorOctaves(this.soulRNG, 16);
  120.         this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.soulRNG, 8);
  121.  
  122.         NoiseGeneratorOctaves[] noiseGens = {netherNoiseGen1, netherNoiseGen2, netherNoiseGen3, lateriteGrassPorphyryNoise, porphyryExclusivityNoiseGen, netherNoiseGen6, netherNoiseGen7, mobSpawnerNoise};
  123.         noiseGens = TerrainGen.getModdedNoiseGenerators(par1World, this.soulRNG, noiseGens);
  124.         this.netherNoiseGen1 = noiseGens[0];
  125.         this.netherNoiseGen2 = noiseGens[1];
  126.         this.netherNoiseGen3 = noiseGens[2];
  127.         this.lateriteGrassPorphyryNoise = noiseGens[3];
  128.         this.porphyryExclusivityNoiseGen = noiseGens[4];
  129.         this.netherNoiseGen6 = noiseGens[5];
  130.         this.netherNoiseGen7 = noiseGens[6];
  131.         this.mobSpawnerNoise = noiseGens[7];
  132.     }
  133.  
  134.    
  135.     /**
  136.      * Generates the shape of the terrain in the nether.
  137.      */
  138.     public void generateNetherTerrain(int par1, int par2, byte[] par3ArrayOfByte)
  139.     {
  140.         byte b0 = 4;
  141.         byte b1 = 32;
  142.         int k = b0 + 1;
  143.         byte b2 = 17;
  144.         int l = b0 + 1;
  145.         this.noiseField = this.initializeNoiseField(this.noiseField, par1 * b0, 0, par2 * b0, k, b2, l);
  146.  
  147.         for (int i1 = 0; i1 < b0; ++i1)
  148.         {
  149.             for (int j1 = 0; j1 < b0; ++j1)
  150.             {
  151.                 for (int k1 = 0; k1 < 16; ++k1)
  152.                 {
  153.                     double d0 = 0.125D;
  154.                     double d1 = this.noiseField[((i1 + 0) * l + j1 + 0) * b2 + k1 + 0];
  155.                     double d2 = this.noiseField[((i1 + 0) * l + j1 + 1) * b2 + k1 + 0];
  156.                     double d3 = this.noiseField[((i1 + 1) * l + j1 + 0) * b2 + k1 + 0];
  157.                     double d4 = this.noiseField[((i1 + 1) * l + j1 + 1) * b2 + k1 + 0];
  158.                     double d5 = (this.noiseField[((i1 + 0) * l + j1 + 0) * b2 + k1 + 1] - d1) * d0;
  159.                     double d6 = (this.noiseField[((i1 + 0) * l + j1 + 1) * b2 + k1 + 1] - d2) * d0;
  160.                     double d7 = (this.noiseField[((i1 + 1) * l + j1 + 0) * b2 + k1 + 1] - d3) * d0;
  161.                     double d8 = (this.noiseField[((i1 + 1) * l + j1 + 1) * b2 + k1 + 1] - d4) * d0;
  162.  
  163.                     for (int l1 = 0; l1 < 8; ++l1)
  164.                     {
  165.                         double d9 = 0.25D;
  166.                         double d10 = d1;
  167.                         double d11 = d2;
  168.                         double d12 = (d3 - d1) * d9;
  169.                         double d13 = (d4 - d2) * d9;
  170.  
  171.                         for (int i2 = 0; i2 < 4; ++i2)
  172.                         {
  173.                             int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1;
  174.                             short short1 = 128;
  175.                             double d14 = 0.25D;
  176.                             double d15 = d10;
  177.                             double d16 = (d11 - d10) * d14;
  178.  
  179.                             for (int k2 = 0; k2 < 4; ++k2)
  180.                             {
  181.                                 int l2 = 0;
  182.  
  183.                                 if (k1 * 8 + l1 < b1)
  184.                                 {
  185.                                     l2 = Block.waterStill.blockID;
  186.                                 }
  187.  
  188.                                 if (d15 > 0.0D)
  189.                                 {
  190.                                     l2 = (byte)mod_Ores.Porphyry.blockID;
  191.                                 }
  192.  
  193.                                 par3ArrayOfByte[j2] = (byte)l2;
  194.                                 j2 += short1;
  195.                                 d15 += d16;
  196.                             }
  197.  
  198.                             d10 += d12;
  199.                             d11 += d13;
  200.                         }
  201.  
  202.                         d1 += d5;
  203.                         d2 += d6;
  204.                         d3 += d7;
  205.                         d4 += d8;
  206.                     }
  207.                 }
  208.             }
  209.         }
  210.     }
  211.  
  212.     /**
  213.      * name based on ChunkProviderGenerate
  214.      */
  215.     public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
  216.     {
  217.         ChunkProviderEvent.ReplaceBiomeBlocks event = new ChunkProviderEvent.ReplaceBiomeBlocks(this, par1, par2, par3ArrayOfByte, null);
  218.         MinecraftForge.EVENT_BUS.post(event);
  219.         if (event.getResult() == Result.DENY) return;
  220.  
  221.         byte b0 = 64;
  222.         double d0 = 0.03125D;
  223.         this.lateriteGrassNoise = this.lateriteGrassPorphyryNoise.generateNoiseOctaves(this.lateriteGrassNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0, d0, 1.0D);
  224.         this.porphyryNoise = this.lateriteGrassPorphyryNoise.generateNoiseOctaves(this.porphyryNoise, par1 * 16, 109, par2 * 16, 16, 1, 16, d0, 1.0D, d0);
  225.         this.porphyryExclusivityNoise = this.porphyryExclusivityNoiseGen.generateNoiseOctaves(this.porphyryExclusivityNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, d0 * 2.0D, d0 * 2.0D, d0 * 2.0D);
  226.  
  227.         for (int k = 0; k < 16; ++k)
  228.         {
  229.             for (int l = 0; l < 16; ++l)
  230.             {
  231.                 BiomeGenBase biomegenbase = par4ArrayOfBiomeGenBase[l + k * 16];
  232.                 boolean flag = this.lateriteGrassNoise[k + l * 16] + this.soulRNG.nextDouble() * 0.2D > 0.0D;
  233.                 boolean flag1 = this.porphyryNoise[k + l * 16] + this.soulRNG.nextDouble() * 0.2D > 0.0D;
  234.                 int i1 = (int)(this.porphyryExclusivityNoise[k + l * 16] / 3.0D + 3.0D + this.soulRNG.nextDouble() * 0.25D);
  235.                 int j1 = -1;
  236.                 byte b1 = biomegenbase.topBlock;
  237.                 byte b2 = biomegenbase.fillerBlock;
  238.  
  239.                 for (int k1 = 127; k1 >= 0; --k1)
  240.                 {
  241.                     int l1 = (l * 16 + k) * 128 + k1;
  242.  
  243.                     if (k1 < 127 - this.soulRNG.nextInt(5) && k1 > 0 + this.soulRNG.nextInt(5))
  244.                     {
  245.                         byte b3 = par3ArrayOfByte[l1];
  246.  
  247.                         if (b3 == 0)
  248.                         {
  249.                             j1 = -1;
  250.                         }
  251.                         else if (b3 == (byte)mod_Ores.Porphyry.blockID)
  252.                         {
  253.                             if (j1 == -1)
  254.                             {
  255.                                 if (i1 <= 0)
  256.                                 {
  257.                                     b1 = 0;
  258.                                     b2 = (byte)mod_Ores.Porphyry.blockID;
  259.                                 }
  260.                                 else if (k1 >= b0 - 4 && k1 <= b0 + 1)
  261.                                 {
  262.                                      b1 = biomegenbase.topBlock;
  263.                                      b2 = biomegenbase.fillerBlock;
  264.  
  265.                                     if (flag1)
  266.                                     {
  267.                                         b1 = (byte)biomegenbase.topBlock;
  268.                                     }
  269.  
  270.                                     if (flag1)
  271.                                     {
  272.                                         b2 = (byte)mod_Ores.Porphyry.blockID;
  273.                                     }
  274.  
  275.                                     if (flag)
  276.                                     {
  277.                                         b1 = (byte)biomegenbase.topBlock;
  278.                                     }
  279.  
  280.                                     if (flag)
  281.                                     {
  282.                                         b2 = (byte)mod_Ores.Slate.blockID;
  283.                                     }
  284.                                 }
  285.  
  286.                                 if (k1 < b0 && b1 == 0)
  287.                                 {
  288.                                     b1 = (byte)Block.waterStill.blockID;
  289.                                 }
  290.  
  291.                                 j1 = i1;
  292.  
  293.                                 if (k1 >= b0 - 1)
  294.                                 {
  295.                                     par3ArrayOfByte[l1] = b1;
  296.                                 }
  297.                                 else
  298.                                 {
  299.                                     par3ArrayOfByte[l1] = b2;
  300.                                 }
  301.                             }
  302.                             else if (j1 > 0)
  303.                             {
  304.                                 --j1;
  305.                                 par3ArrayOfByte[l1] = b2;
  306.                             }
  307.                         }
  308.                     }
  309.                     else
  310.                     {
  311.                         par3ArrayOfByte[l1] = (byte)Block.bedrock.blockID;
  312.                     }
  313.                 }
  314.             }
  315.         }
  316.     }
  317.  
  318.     /**
  319.      * loads or generates the chunk at the chunk location specified
  320.      */
  321.     public Chunk loadChunk(int par1, int par2)
  322.     {
  323.         return this.provideChunk(par1, par2);
  324.     }
  325.  
  326.     /**
  327.      * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the
  328.      * specified chunk from the map seed and chunk seed
  329.      */
  330.     @Override
  331.     public Chunk provideChunk(int par1, int par2)
  332.     {
  333.         this.soulRNG.setSeed((long)par1 * 341873128712L + (long)par2 * 132897987541L);
  334.         byte[] abyte = new byte[32768];
  335.         this.generateNetherTerrain(par1, par2, abyte);
  336.         this.biomesForGeneration = (BiomeGenBase[]) this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
  337.         this.replaceBlocksForBiome(par1, par2, abyte, this.biomesForGeneration);
  338.         this.netherCaveGenerator.generate(this, this.worldObj, par1, par2, abyte);
  339.         this.genNetherBridge.generate(this, this.worldObj, par1, par2, abyte);
  340.         Chunk chunk = new Chunk(this.worldObj, abyte, par1, par2);
  341.         BiomeGenBase[] abiomegenbase = (BiomeGenBase[]) this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[])null, par1 * 16, par2 * 16, 16, 16);
  342.         byte[] abyte1 = chunk.getBiomeArray();
  343.  
  344.         for (int k = 0; k < abyte1.length; ++k)
  345.         {
  346.             abyte1[k] = (byte)abiomegenbase[k].biomeID;
  347.         }
  348.  
  349.         chunk.resetRelightChecks();
  350.         return chunk;
  351.     }
  352.  
  353.     public void decorate(World par1World, Random par2Random, int par3, int par4)
  354.     {
  355.         ((BiomeGenBase) this.theBiomeDecorator).decorate(par1World, par2Random, par3, par4);
  356.     }
  357.     /**
  358.      * generates a subset of the level's terrain data. Takes 7 arguments: the [empty] noise array, the position, and the
  359.      * size.
  360.      */
  361.     private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
  362.     {
  363.         ChunkProviderEvent.InitNoiseField event = new ChunkProviderEvent.InitNoiseField(this, par1ArrayOfDouble, par2, par3, par4, par5, par6, par7);
  364.         MinecraftForge.EVENT_BUS.post(event);
  365.         if (event.getResult() == Result.DENY) return event.noisefield;
  366.         if (par1ArrayOfDouble == null)
  367.         {
  368.             par1ArrayOfDouble = new double[par5 * par6 * par7];
  369.         }
  370.  
  371.         double d0 = 684.412D;
  372.         double d1 = 2053.236D;
  373.         this.noiseData4 = this.netherNoiseGen6.generateNoiseOctaves(this.noiseData4, par2, par3, par4, par5, 1, par7, 1.0D, 0.0D, 1.0D);
  374.         this.noiseData5 = this.netherNoiseGen7.generateNoiseOctaves(this.noiseData5, par2, par3, par4, par5, 1, par7, 100.0D, 0.0D, 100.0D);
  375.         this.noiseData1 = this.netherNoiseGen3.generateNoiseOctaves(this.noiseData1, par2, par3, par4, par5, par6, par7, d0 / 80.0D, d1 / 60.0D, d0 / 80.0D);
  376.         this.noiseData2 = this.netherNoiseGen1.generateNoiseOctaves(this.noiseData2, par2, par3, par4, par5, par6, par7, d0, d1, d0);
  377.         this.noiseData3 = this.netherNoiseGen2.generateNoiseOctaves(this.noiseData3, par2, par3, par4, par5, par6, par7, d0, d1, d0);
  378.         int k1 = 0;
  379.         int l1 = 0;
  380.         double[] adouble1 = new double[par6];
  381.         int i2;
  382.  
  383.         for (i2 = 0; i2 < par6; ++i2)
  384.         {
  385.             adouble1[i2] = Math.cos((double)i2 * Math.PI * 6.0D / (double)par6) * 2.0D;
  386.             double d2 = (double)i2;
  387.  
  388.             if (i2 > par6 / 2)
  389.             {
  390.                 d2 = (double)(par6 - 1 - i2);
  391.             }
  392.  
  393.             if (d2 < 4.0D)
  394.             {
  395.                 d2 = 4.0D - d2;
  396.                 adouble1[i2] -= d2 * d2 * d2 * 10.0D;
  397.             }
  398.         }
  399.  
  400.         for (i2 = 0; i2 < par5; ++i2)
  401.         {
  402.             for (int j2 = 0; j2 < par7; ++j2)
  403.             {
  404.                 double d3 = (this.noiseData4[l1] + 256.0D) / 512.0D;
  405.  
  406.                 if (d3 > 1.0D)
  407.                 {
  408.                     d3 = 1.0D;
  409.                 }
  410.  
  411.                 double d4 = 0.0D;
  412.                 double d5 = this.noiseData5[l1] / 8000.0D;
  413.  
  414.                 if (d5 < 0.0D)
  415.                 {
  416.                     d5 = -d5;
  417.                 }
  418.  
  419.                 d5 = d5 * 3.0D - 3.0D;
  420.  
  421.                 if (d5 < 0.0D)
  422.                 {
  423.                     d5 /= 2.0D;
  424.  
  425.                     if (d5 < -1.0D)
  426.                     {
  427.                         d5 = -1.0D;
  428.                     }
  429.  
  430.                     d5 /= 1.4D;
  431.                     d5 /= 2.0D;
  432.                     d3 = 0.0D;
  433.                 }
  434.                 else
  435.                 {
  436.                     if (d5 > 1.0D)
  437.                     {
  438.                         d5 = 1.0D;
  439.                     }
  440.  
  441.                     d5 /= 6.0D;
  442.                 }
  443.  
  444.                 d3 += 0.5D;
  445.                 d5 = d5 * (double)par6 / 16.0D;
  446.                 ++l1;
  447.  
  448.                 for (int k2 = 0; k2 < par6; ++k2)
  449.                 {
  450.                     double d6 = 0.0D;
  451.                     double d7 = adouble1[k2];
  452.                     double d8 = this.noiseData2[k1] / 512.0D;
  453.                     double d9 = this.noiseData3[k1] / 512.0D;
  454.                     double d10 = (this.noiseData1[k1] / 10.0D + 1.0D) / 2.0D;
  455.  
  456.                     if (d10 < 0.0D)
  457.                     {
  458.                         d6 = d8;
  459.                     }
  460.                     else if (d10 > 1.0D)
  461.                     {
  462.                         d6 = d9;
  463.                     }
  464.                     else
  465.                     {
  466.                         d6 = d8 + (d9 - d8) * d10;
  467.                     }
  468.  
  469.                     d6 -= d7;
  470.                     double d11;
  471.  
  472.                     if (k2 > par6 - 4)
  473.                     {
  474.                         d11 = (double)((float)(k2 - (par6 - 4)) / 3.0F);
  475.                         d6 = d6 * (1.0D - d11) + -10.0D * d11;
  476.                     }
  477.  
  478.                     if ((double)k2 < d4)
  479.                     {
  480.                         d11 = (d4 - (double)k2) / 4.0D;
  481.  
  482.                         if (d11 < 0.0D)
  483.                         {
  484.                             d11 = 0.0D;
  485.                         }
  486.  
  487.                         if (d11 > 1.0D)
  488.                         {
  489.                             d11 = 1.0D;
  490.                         }
  491.  
  492.                         d6 = d6 * (1.0D - d11) + -10.0D * d11;
  493.                     }
  494.  
  495.                     par1ArrayOfDouble[k1] = d6;
  496.                     ++k1;
  497.                 }
  498.             }
  499.         }
  500.  
  501.         return par1ArrayOfDouble;
  502.     }
  503.  
  504.     /**
  505.      * Checks to see if a chunk exists at x, y
  506.      */
  507.     public boolean chunkExists(int par1, int par2)
  508.     {
  509.         return true;
  510.     }
  511.  
  512.     /**
  513.      * Populates chunk with ores etc etc
  514.      */
  515.     public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)
  516.     {
  517.         BlockSand.fallInstantly = true;
  518.  
  519.         MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Pre(par1IChunkProvider, worldObj, soulRNG, par2, par3, false));
  520.  
  521.         int k = par2 * 16;
  522.         int l = par3 * 16;
  523.         //this.genNetherBridge.generateStructuresInChunk(this.worldObj, this.soulRNG, par2, par3);
  524.         int i1;
  525.         int j1;
  526.         int k1;
  527.         int l1 = 0;
  528.  
  529.         boolean doGen = TerrainGen.populate(par1IChunkProvider, worldObj, soulRNG, par2, par3, false, NETHER_LAVA);
  530.         for (i1 = 0; doGen && i1 < 8; ++i1)
  531.         {
  532.             j1 = k + this.soulRNG.nextInt(16) + 8;
  533.             k1 = this.soulRNG.nextInt(128) + 4;
  534.             l1 = l + this.soulRNG.nextInt(16) + 8;
  535.             (new WorldGenHellLava(Block.waterMoving.blockID, false)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  536.         }
  537.        
  538.         //doGen = TerrainGen.populate(par1IChunkProvider, worldObj, soulRNG, par2, par3, false, DUNGEON);
  539.  
  540.         MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Pre(worldObj, soulRNG, k, l));
  541.  
  542.         i1 = this.soulRNG.nextInt(this.soulRNG.nextInt(10) + 1) + 1;
  543.         int i2;
  544.        
  545.         doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, SHROOM);
  546.         if (doGen && this.soulRNG.nextInt(1) == 0)
  547.         {
  548.             j1 = k + this.soulRNG.nextInt(16) + 8;
  549.             k1 = this.soulRNG.nextInt(128);
  550.             l1 = l + this.soulRNG.nextInt(16) + 8;
  551.             (new WorldGenFlowers(Block.mushroomBrown.blockID)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  552.         }
  553.  
  554.         doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, SHROOM);
  555.         if (doGen && this.soulRNG.nextInt(1) == 0)
  556.         {
  557.             j1 = k + this.soulRNG.nextInt(16) + 8;
  558.             k1 = this.soulRNG.nextInt(128);
  559.             l1 = l + this.soulRNG.nextInt(16) + 8;
  560.             (new WorldGenFlowers(Block.mushroomRed.blockID)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  561.         }
  562.        
  563.         /*doGen = TerrainGen.decorate(worldObj, soulRNG, k, l, FLOWERS);
  564.         if (doGen && this.soulRNG.nextInt(1) == 0)
  565.         {
  566.             j1 = k + this.soulRNG.nextInt(16) + 8;
  567.             k1 = this.soulRNG.nextInt(128);
  568.             l1 = l + this.soulRNG.nextInt(16) + 8;
  569.             (new WorldGenFlowers(mod_Ores.plantCantaloupe.blockID)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  570.         }*/
  571.        
  572.        
  573.         for (int i = 0; i < 1; ++i)
  574.         {
  575.             j1 = k + soulRNG.nextInt(16);
  576.             k1 = soulRNG.nextInt(128);
  577.             l1 = l + soulRNG.nextInt(16);
  578.             (new WorldGenSoulTemple()).generate(worldObj, soulRNG, j1, k1, l1);
  579.         }
  580.         for (int i = 0; i < 1; ++i)
  581.         {
  582.             j1 = k + soulRNG.nextInt(16) + 32;
  583.             k1 = soulRNG.nextInt(128);
  584.             l1 = l + soulRNG.nextInt(16) + 32;
  585.             (new WorldGenIceTower()).generate(worldObj, soulRNG, j1, k1, l1);
  586.         }
  587.         for (int g1 = 0; g1 < 60; g1++)
  588.         {
  589.             j1 = k + this.soulRNG.nextInt(16);
  590.             k1 = this.soulRNG.nextInt(128);
  591.             l1 = l + this.soulRNG.nextInt(16);
  592.         (new WorldGenGrapeTree(false)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  593.         }
  594.         //vines
  595.         for (int g1 = 0; g1 < 8; g1++)
  596.         {
  597.             j1 = k + this.soulRNG.nextInt(16) + 8;
  598.             k1 = this.soulRNG.nextInt(128);
  599.             l1 = l + this.soulRNG.nextInt(16) + 8;
  600.         (new WorldGenBaneberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  601.         }
  602.         for (int g1 = 0; g1 < 7; g1++)
  603.         {
  604.             j1 = k + this.soulRNG.nextInt(16) + 8;
  605.             k1 = this.soulRNG.nextInt(128);
  606.             l1 = l + this.soulRNG.nextInt(16) + 8;
  607.         (new WorldGenBlueberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  608.         }
  609.         for (int g1 = 0; g1 < 9; g1++)
  610.         {
  611.             j1 = k + this.soulRNG.nextInt(16) + 8;
  612.             k1 = this.soulRNG.nextInt(128);
  613.             l1 = l + this.soulRNG.nextInt(16) + 8;
  614.         (new WorldGenBlackberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  615.         }
  616.         for (int g1 = 0; g1 < 13; g1++)
  617.         {
  618.             j1 = k + this.soulRNG.nextInt(16) + 8;
  619.             k1 = this.soulRNG.nextInt(128);
  620.             l1 = l + this.soulRNG.nextInt(16) + 8;
  621.         (new WorldGenCranberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  622.         }
  623.         for (int g1 = 0; g1 < 10; g1++)
  624.         {
  625.             j1 = k + this.soulRNG.nextInt(16) + 8;
  626.             k1 = this.soulRNG.nextInt(128);
  627.             l1 = l + this.soulRNG.nextInt(16) + 8;
  628.         (new WorldGenRaspberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  629.         }
  630.         for (int g1 = 0; g1 < 12; g1++)
  631.         {
  632.             j1 = k + this.soulRNG.nextInt(16) + 8;
  633.             k1 = this.soulRNG.nextInt(128);
  634.             l1 = l + this.soulRNG.nextInt(16) + 8;
  635.         (new WorldGenRazzberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  636.         }
  637.         for (int g1 = 0; g1 < 15; g1++)
  638.         {
  639.             j1 = k + this.soulRNG.nextInt(16) + 8;
  640.             k1 = this.soulRNG.nextInt(128);
  641.             l1 = l + this.soulRNG.nextInt(16) + 8;
  642.         (new WorldGenStrawberryVines()).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  643.         }
  644.       //flowers
  645.         /*for (int g1 = 0; g1 < 10; g1++)
  646.         {      
  647.             j1 = k + this.soulRNG.nextInt(16) + 8;
  648.             k1 = this.soulRNG.nextInt(128);
  649.             l1 = l + this.soulRNG.nextInt(16) + 8;
  650.         (new WorldGenCantaloupe(2000)).generate(this.worldObj, this.soulRNG, j1, k1, l1);
  651.         }*/
  652.                
  653.         // #region Ore Gen
  654.         WorldGenMinable worldgenminable;
  655.         int j2;
  656.  
  657.         for (int i = 0; i < 7; i++)
  658.         {
  659.             int randPosX = k + soulRNG.nextInt(16);
  660.             int randPosY = soulRNG.nextInt(128);                //Rarerity 6 (1-15) 1 is very common 15 is extremely rare
  661.             int randPosZ = l + soulRNG.nextInt(16);
  662.             (new WorldGenMinable(mod_Ores.Amazoniteore.blockID, 7, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  663.         }
  664.         for (int i = 0; i < 9; i++)
  665.         {
  666.             int randPosX = k + soulRNG.nextInt(16);
  667.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  668.             int randPosZ = l + soulRNG.nextInt(16);
  669.             (new WorldGenMinable(mod_Ores.Amethystore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  670.         }
  671.         for (int i = 0; i < 9; i++)
  672.         {
  673.             int randPosX = k + soulRNG.nextInt(16);
  674.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  675.             int randPosZ = l + soulRNG.nextInt(16);
  676.             (new WorldGenMinable(mod_Ores.Aquamarineore.blockID, 9, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  677.         }
  678.         for (int i = 0; i < 2; i++)
  679.         {
  680.             int randPosX = k + soulRNG.nextInt(16);
  681.             int randPosY = soulRNG.nextInt(128);                //Rarerity 12 (1-15) 1 is very common 15 is extremely rare
  682.             int randPosZ = l + soulRNG.nextInt(16);
  683.             (new WorldGenMinable(mod_Ores.Blackdiamondore.blockID, 5, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  684.         }
  685.         for (int i = 0; i < 7; i++)
  686.         {
  687.             int randPosX = k + soulRNG.nextInt(16);
  688.             int randPosY = soulRNG.nextInt(128);                //Rarerity 6 (1-15) 1 is very common 15 is extremely rare
  689.             int randPosZ = l + soulRNG.nextInt(16);
  690.             (new WorldGenMinable(mod_Ores.Chromiteore.blockID, 7, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  691.         }
  692.         for (int i = 0; i < 9; i++)
  693.         {
  694.             int randPosX = k + soulRNG.nextInt(16);
  695.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  696.             int randPosZ = l + soulRNG.nextInt(16);
  697.             (new WorldGenMinable(mod_Ores.Citrineore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  698.         }
  699.         for (int i = 0; i < 7; i++)
  700.         {
  701.             int randPosX = k + soulRNG.nextInt(16);
  702.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  703.             int randPosZ = l + soulRNG.nextInt(16);
  704.             (new WorldGenMinable(mod_Ores.Emeraldore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  705.         }
  706.         for (int i = 0; i < 9; i++)
  707.         {
  708.             int randPosX = k + soulRNG.nextInt(16);
  709.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  710.             int randPosZ = l + soulRNG.nextInt(16);
  711.             (new WorldGenMinable(mod_Ores.Jadeore.blockID, 8, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  712.         }
  713.         for (int i = 0; i < 9; i++)
  714.         {
  715.             int randPosX = k + soulRNG.nextInt(16);
  716.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  717.             int randPosZ = l + soulRNG.nextInt(16);
  718.             (new WorldGenMinable(mod_Ores.Jetore.blockID, 8, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  719.         }
  720.         for (int i = 0; i < 9; i++)
  721.         {
  722.             int randPosX = k + soulRNG.nextInt(16);
  723.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  724.             int randPosZ = l + soulRNG.nextInt(16);
  725.             (new WorldGenMinable(mod_Ores.Lilaore.blockID, 9, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  726.         }
  727.         for (int i = 0; i < 4; i++)
  728.         {
  729.             int randPosX = k + soulRNG.nextInt(16);
  730.             int randPosY = soulRNG.nextInt(128);                //Rarerity 8 (1-15) 1 is very common 15 is extremely rare
  731.             int randPosZ = l + soulRNG.nextInt(16);
  732.             (new WorldGenMinable(mod_Ores.Mithrilore.blockID, 6, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  733.         }
  734.         for (int i = 0; i < 8; i++)
  735.         {
  736.             int randPosX = k + soulRNG.nextInt(16);
  737.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  738.             int randPosZ = l + soulRNG.nextInt(16);
  739.             (new WorldGenMinable(mod_Ores.Olivineore.blockID, 8, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  740.         }
  741.         for (int i = 0; i < 2; i++)
  742.         {
  743.             int randPosX = k + soulRNG.nextInt(16);
  744.             int randPosY = soulRNG.nextInt(128);                //Rarerity 10 (1-15) 1 is very common 15 is extremely rare
  745.             int randPosZ = l + soulRNG.nextInt(16);
  746.             (new WorldGenMinable(mod_Ores.Onyxore.blockID, 4, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  747.         }
  748.         for (int i = 0; i < 13; i++)
  749.         {
  750.             int randPosX = k + soulRNG.nextInt(16);
  751.             int randPosY = soulRNG.nextInt(128);                //Rarerity 1 (1-15) 1 is very common 15 is extremely rare
  752.             int randPosZ = l + soulRNG.nextInt(16);
  753.             (new WorldGenMinable(mod_Ores.Opalore.blockID, 12, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  754.         }
  755.         for (int i = 0; i < 8 ; i++)
  756.         {
  757.             int randPosX = k + soulRNG.nextInt(16);
  758.             int randPosY = soulRNG.nextInt(128);                //Rarerity 5 (1-15) 1 is very common 15 is extremely rare
  759.             int randPosZ = l + soulRNG.nextInt(16);
  760.             (new WorldGenMinable(mod_Ores.Rubyore.blockID, 5, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  761.         }
  762.         for (int i = 0; i < 8; i++)
  763.         {
  764.             int randPosX = k + soulRNG.nextInt(16);
  765.             int randPosY = soulRNG.nextInt(128);                //Rarerity 5 (1-15) 1 is very common 15 is extremely rare
  766.             int randPosZ = l + soulRNG.nextInt(16);
  767.             (new WorldGenMinable(mod_Ores.Sapphireore.blockID, 5, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  768.         }
  769.         for (int i = 0; i < 9; i++)
  770.         {
  771.             int randPosX = k + soulRNG.nextInt(16);
  772.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  773.             int randPosZ = l + soulRNG.nextInt(16);
  774.             (new WorldGenMinable(mod_Ores.Scarletiteore.blockID, 6, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  775.         }
  776.         for (int i = 0; i < 9; i++)
  777.         {
  778.             int randPosX = k + soulRNG.nextInt(16);
  779.             int randPosY = soulRNG.nextInt(128);                //Rarerity 4 (1-15) 1 is very common 15 is extremely rare
  780.             int randPosZ = l + soulRNG.nextInt(16);
  781.             (new WorldGenMinable(mod_Ores.Tanzaniteore.blockID, 7, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  782.         }
  783.         for (int i = 0; i < 2; i++)
  784.         {
  785.             int randPosX = k + soulRNG.nextInt(16);
  786.             int randPosY = soulRNG.nextInt(128);                //Rarerity 11 (1-15) 1 is very common 15 is extremely rare
  787.             int randPosZ = l + soulRNG.nextInt(16);
  788.             (new WorldGenMinable(mod_Ores.Titaniumore.blockID, 4, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  789.         }
  790.         for (int i = 0; i < 10; i++)
  791.         {
  792.             int randPosX = k + soulRNG.nextInt(16);
  793.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  794.             int randPosZ = l + soulRNG.nextInt(16);
  795.             (new WorldGenMinable(mod_Ores.Topazore.blockID, 7, mod_Ores.Slate.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  796.         }
  797.         for (int i = 0; i < 10; i++)
  798.         {
  799.             int randPosX = k + soulRNG.nextInt(16);
  800.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  801.             int randPosZ = l + soulRNG.nextInt(16);
  802.             (new WorldGenMinable(mod_Ores.Turquoiseore.blockID, 8, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  803.         }
  804.         for (int i = 0; i < 10; i++)
  805.         {
  806.             int randPosX = k + soulRNG.nextInt(16);
  807.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  808.             int randPosZ = l + soulRNG.nextInt(16);
  809.             (new WorldGenMinable(mod_Ores.Violetore.blockID, 7, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  810.         }
  811.         for (int i = 0; i < 10; i++)
  812.         {
  813.             int randPosX = k + soulRNG.nextInt(16);
  814.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  815.             int randPosZ = l + soulRNG.nextInt(16);
  816.             (new WorldGenMinable(mod_Ores.Whiteopalore.blockID, 6, mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  817.         }      
  818.         for (int i = 0; i < 5; i++)
  819.         {
  820.             int randPosX = k + soulRNG.nextInt(16);
  821.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  822.             int randPosZ = l + soulRNG.nextInt(16);
  823.             (new WorldGenMinable(mod_Ores.Bauxite.blockID, 30,mod_Ores.Porphyry.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  824.         }  
  825.         for (int i = 0; i < 35; i++)
  826.         {
  827.             int randPosX = k + soulRNG.nextInt(16);
  828.             int randPosY = soulRNG.nextInt(128);                //Rarerity 3 (1-15) 1 is very common 15 is extremely rare
  829.             int randPosZ = l + soulRNG.nextInt(16);
  830.             (new WorldGenMinable(mod_Ores.SoulSnowTop.blockID, 30,mod_Ores.SoulSnowBottom.blockID)).generate(worldObj, soulRNG, randPosX, randPosY, randPosZ);
  831.         }  
  832.  
  833.         for (k1 = 0; k1 < 16; ++k1)
  834.         {
  835.             l1 = k + this.soulRNG.nextInt(16);
  836.             i2 = this.soulRNG.nextInt(108) + 10;
  837.             j2 = l + this.soulRNG.nextInt(16);
  838.             (new WorldGenHellLava(Block.waterMoving.blockID, true)).generate(this.worldObj, this.soulRNG, l1, i2, j2);
  839.         }
  840.  
  841.         MinecraftForge.EVENT_BUS.post(new DecorateBiomeEvent.Post(worldObj, soulRNG, k, l));
  842.         MinecraftForge.EVENT_BUS.post(new PopulateChunkEvent.Post(par1IChunkProvider, worldObj, soulRNG, par2, par3, false));
  843.  
  844.         BlockSand.fallInstantly = false;
  845.     }
  846.  
  847.     /**
  848.      * Two modes of operation: if passed true, save all Chunks in one go.  If passed false, save up to two chunks.
  849.      * Return true if all chunks have been saved.
  850.      */
  851.     public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate)
  852.     {
  853.         return true;
  854.     }
  855.  
  856.     /**
  857.      * Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk.
  858.      */
  859.     public boolean unloadQueuedChunks()
  860.     {
  861.         return false;
  862.     }
  863.  
  864.     /**
  865.      * Returns if the IChunkProvider supports saving.
  866.      */
  867.     public boolean canSave()
  868.     {
  869.         return true;
  870.     }
  871.  
  872.     /**
  873.      * Converts the instance data to a readable string.
  874.      */
  875.     public String makeString()
  876.     {
  877.         return "SoulForestLevelSource";
  878.     }
  879.  
  880.     /**
  881.      * Returns a list of creatures of the specified type that can spawn at the given location.
  882.      */
  883.     public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
  884.     {
  885.         if (par1EnumCreatureType == EnumCreatureType.monster && this.genNetherBridge.hasStructureAt(par2, par3, par4))
  886.         {
  887.             return this.genNetherBridge.getSpawnList();
  888.         }
  889.         else
  890.         {
  891.             BiomeGenBase biomegenbase = (BiomeGenBase) this.worldObj.getBiomeGenForCoords(par2, par4);
  892.             return biomegenbase == null ? null : biomegenbase.getSpawnableList(par1EnumCreatureType);
  893.         }
  894.     }
  895.  
  896.     /**
  897.      * Returns the location of the closest structure of the specified type. If not found returns null.
  898.      */
  899.     public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
  900.     {
  901.         return null;
  902.     }
  903.  
  904.     public int getLoadedChunkCount()
  905.     {
  906.         return 0;
  907.     }
  908.  
  909.     public void recreateStructures(int par1, int par2)
  910.     {
  911.         //this.genNetherBridge.generate(this, this.worldObj, par1, par2, (byte[])null);
  912.     }
  913.  
  914.     @Override
  915.     public void func_104112_b() {}
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!