API tools faq
paste
lol123406

Untitled

lol123406
Aug 25th, 2015
288
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 16.75 KB | None | 0 0
raw download clone embed print report
  1. package net.Ethereal.world;
  2.  
  3. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.CAVE;
  4. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.MINESHAFT;
  5. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.RAVINE;
  6. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.SCATTERED_FEATURE;
  7. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.STRONGHOLD;
  8. import static net.minecraftforge.event.terraingen.InitMapGenEvent.EventType.VILLAGE;
  9. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.DUNGEON;
  10. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.ICE;
  11. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAKE;
  12. import static net.minecraftforge.event.terraingen.PopulateChunkEvent.Populate.EventType.LAVA;
  13.  
  14. import java.util.List;
  15. import java.util.Random;
  16.  
  17. import net.minecraft.block.Block;
  18. import net.minecraft.entity.EnumCreatureType;
  19. import net.minecraft.util.IProgressUpdate;
  20. import net.minecraft.util.MathHelper;
  21. import net.minecraft.world.ChunkPosition;
  22. import net.minecraft.world.SpawnerAnimals;
  23. import net.minecraft.world.World;
  24. import net.minecraft.world.biome.BiomeGenBase;
  25. import net.minecraft.world.biome.WorldChunkManager;
  26. import net.minecraft.world.chunk.Chunk;
  27. import net.minecraft.world.chunk.IChunkProvider;
  28. import net.minecraft.world.gen.MapGenBase;
  29. import net.minecraft.world.gen.MapGenCaves;
  30. import net.minecraft.world.gen.MapGenRavine;
  31. import net.minecraft.world.gen.NoiseGeneratorOctaves;
  32. import net.minecraft.world.gen.feature.WorldGenLakes;
  33. import net.minecraft.world.gen.structure.MapGenMineshaft;
  34. import net.minecraft.world.gen.structure.MapGenScatteredFeature;
  35. import net.minecraft.world.gen.structure.MapGenStronghold;
  36. import net.minecraft.world.gen.structure.MapGenVillage;
  37.  
  38. public class ChunkProviderMinelands implements IChunkProvider
  39. {
  40. private Random rand;
  41. private NoiseGeneratorOctaves noiseGen1;
  42. private NoiseGeneratorOctaves noiseGen2;
  43. private NoiseGeneratorOctaves noiseGen3;
  44. private NoiseGeneratorOctaves noiseGen4;
  45. public NoiseGeneratorOctaves noiseGen5;
  46. public NoiseGeneratorOctaves noiseGen6;
  47. public NoiseGeneratorOctaves mobSpawnerNoise;
  48. private World worldObj;
  49. private final boolean mapFeaturesEnabled;
  50. private double[] noiseArray;
  51. private double[] stoneNoise = new double[256];
  52. private MapGenBase caveGenerator = new MapGenCaves();
  53. private MapGenStronghold strongholdGenerator = new MapGenStronghold();
  54. private MapGenVillage villageGenerator = new MapGenVillage();
  55. private MapGenMineshaft mineshaftGenerator = new MapGenMineshaft();
  56. private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();
  57. private MapGenBase ravineGenerator = new MapGenRavine();
  58. private BiomeGenBase[] biomesForGeneration;
  59. double[] noise3;
  60. double[] noise1;
  61. double[] noise2;
  62. double[] noise5;
  63. double[] noise6;
  64. float[] parabolicField;
  65. int[][] field_73219_j = new int[32][32];
  66. public ChunkProviderMinelands(World par1World, long par2, boolean par4) {
  67. this.worldObj = par1World;
  68. this.mapFeaturesEnabled = par4;
  69. this.rand = new Random(par2);
  70. this.noiseGen1 = new NoiseGeneratorOctaves(this.rand, 16);
  71. this.noiseGen2 = new NoiseGeneratorOctaves(this.rand, 16);
  72. this.noiseGen3 = new NoiseGeneratorOctaves(this.rand, 8);
  73. this.noiseGen4 = new NoiseGeneratorOctaves(this.rand, 4);
  74. this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
  75. this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
  76. this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
  77. }
  78. /**
  79. * Generates the shape of the terrain for the chunk though its all stone though the water is frozen if the
  80. * temperature is low enough
  81. */
  82. public void generateTerrain(int par1, int par2, byte[] par3ArrayOfByte)
  83. {
  84. byte b0 = 4;
  85. byte b1 = 16;
  86. byte b2 = 63;
  87. int k = b0 + 1;
  88. byte b3 = 17;
  89. int l = b0 + 1;
  90. this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, par1 * 4 - 2, par2 * 4 - 2, k + 5, l + 5);
  91. this.noiseArray = this.initializeNoiseField(this.noiseArray, par1 * b0, 0, par2 * b0, k, b3, l);
  92. for (int i1 = 0; i1 < b0; ++i1)
  93. {
  94. for (int j1 = 0; j1 < b0; ++j1)
  95. {
  96. for (int k1 = 0; k1 < b1; ++k1)
  97. {
  98.          double d0 = 0.125D;
  99.          double d1 = this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 0];
  100.          double d2 = this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 0];
  101.          double d3 = this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 0];
  102.          double d4 = this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 0];
  103.          double d5 = (this.noiseArray[((i1 + 0) * l + j1 + 0) * b3 + k1 + 1] - d1) * d0;
  104.          double d6 = (this.noiseArray[((i1 + 0) * l + j1 + 1) * b3 + k1 + 1] - d2) * d0;
  105.          double d7 = (this.noiseArray[((i1 + 1) * l + j1 + 0) * b3 + k1 + 1] - d3) * d0;
  106.          double d8 = (this.noiseArray[((i1 + 1) * l + j1 + 1) * b3 + k1 + 1] - d4) * d0;
  107.          for (int l1 = 0; l1 < 8; ++l1)
  108.          {
  109.          double d9 = 0.25D;
  110.          double d10 = d1;
  111.          double d11 = d2;
  112.          double d12 = (d3 - d1) * d9;
  113.          double d13 = (d4 - d2) * d9;
  114.          for (int i2 = 0; i2 < 4; ++i2)
  115.          {
  116.          int j2 = i2 + i1 * 4 << 11 | 0 + j1 * 4 << 7 | k1 * 8 + l1;
  117.          short short1 = 128;
  118.          j2 -= short1;
  119.          double d14 = 0.25D;
  120.          double d15 = (d11 - d10) * d14;
  121.          double d16 = d10 - d15;
  122.          for (int k2 = 0; k2 < 4; ++k2)
  123.          {
  124.          if ((d16 += d15) > 0.0D)
  125.          {
  126.                  /** Main filler block fill's all the underground, replaces block stone **/
  127.                  par3ArrayOfByte[j2 += short1] = (byte)Block.stone.blockID;//
  128.          }
  129.          else if (k1 * 8 + l1 < b2)
  130.          {
  131.                  par3ArrayOfByte[j2 += short1] = (byte)Block.waterStill.blockID;
  132.          }
  133.          else
  134.          {
  135.                  par3ArrayOfByte[j2 += short1] = 0;
  136.          }
  137.          }
  138.          d10 += d12;
  139.          d11 += d13;
  140.          }
  141.          d1 += d5;
  142.          d2 += d6;
  143.          d3 += d7;
  144.          d4 += d8;
  145.          }
  146. }
  147. }
  148. }
  149. }
  150. public void replaceBlocksForBiome(int par1, int par2, byte[] par3ArrayOfByte, BiomeGenBase[] par4ArrayOfBiomeGenBase)
  151. {
  152. byte var5 = 63;
  153. double var6 = 0.03125D;
  154. this.stoneNoise = this.noiseGen4.generateNoiseOctaves(this.stoneNoise, par1 * 16, par2 * 16, 0, 16, 16, 1, var6 * 2.0D, var6 * 2.0D, var6 * 2.0D);
  155. for (int var8 = 0; var8 < 16; var8++)
  156. {
  157. for (int var9 = 0; var9 < 16; var9++)
  158. {
  159. BiomeGenBase var10 = par4ArrayOfBiomeGenBase[(var9 + var8 * 16)];
  160. float var11 = var10.getFloatTemperature();
  161. int var12 = (int)(this.stoneNoise[(var8 + var9 * 16)] / 3.0D + 3.0D + this.rand.nextDouble() * 0.25D);
  162. int var13 = -1;
  163. byte var14 = var10.topBlock;
  164. byte var15 = var10.fillerBlock;
  165. for (int var16 = 127; var16 >= 0; var16--)
  166. {
  167.          int var17 = (var9 * 16 + var8) * 128 + var16;
  168.          if (var16 <= 0 + this.rand.nextInt(5))
  169.          {
  170.          par3ArrayOfByte[var17] = ((byte)Block.bedrock.blockID);
  171.          }
  172.          else
  173.          {
  174.          byte var18 = par3ArrayOfByte[var17];
  175.          if (var18 == 0)
  176.          {
  177.          var13 = -1;
  178.          }
  179.          /** Main filler block fill's all the underground, replaces block stone **/
  180.          else if (var18 != Block.stone.blockID)
  181.          {
  182.          if (var13 == -1)
  183.          {
  184.          if (var12 == 0)
  185.          {
  186.                  var14 = 0;
  187.                
  188.                  /** change to custom dirt **/
  189.                  var15 = (byte)Block.dirt.blockID;//
  190.          }
  191.          else if ((var16 >= var5 - 4) && (var16 <= var5 + 1))
  192.          {
  193.                  var14 = var10.topBlock;
  194.                  var15 = var10.fillerBlock;
  195.          }
  196.          if ((var16 < var5) && (var14 == 0))
  197.          {
  198.                  if (var11 < 0.15F)
  199.                  {
  200.                  var14 = (byte)Block.ice.blockID;
  201.                  }
  202.                  else
  203.                  {
  204.                  var14 = (byte)Block.waterStill.blockID;
  205.                  }
  206.          }
  207.          var13 = var12;
  208.          if (var16 >= var5 - 1)
  209.          {
  210.                  par3ArrayOfByte[var17] = var14;
  211.          }
  212.          else
  213.          {
  214.                  par3ArrayOfByte[var17] = var15;
  215.          }
  216.          }
  217.          else if (var13 > 0)
  218.          {
  219.          var13--;
  220.          par3ArrayOfByte[var17] = var15;
  221.          if ((var13 == 0) && (var15 == Block.sand.blockID))
  222.          {
  223.                  var13 = this.rand.nextInt(4);
  224.                  var15 = (byte)Block.sandStone.blockID;
  225.          }
  226.          }
  227.          }
  228.          }
  229. }
  230. }
  231. }
  232. }
  233. public Chunk loadChunk(int par1, int par2)
  234. {
  235. return provideChunk(par1, par2);
  236. }
  237. public Chunk provideChunk(int par1, int par2)
  238. {
  239. this.rand.setSeed(par1 * 341873128712L + par2 * 132897987541L);
  240. byte[] var3 = new byte[32768];
  241. generateTerrain(par1, par2, var3);
  242. this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, par1 * 16, par2 * 16, 16, 16);
  243. replaceBlocksForBiome(par1, par2, var3, this.biomesForGeneration);
  244. this.caveGenerator.generate(this, this.worldObj, par1, par2, var3);
  245. this.ravineGenerator.generate(this, this.worldObj, par1, par2, var3);
  246. if (this.mapFeaturesEnabled)
  247. {
  248. this.mineshaftGenerator.generate(this, this.worldObj, par1, par2, var3);
  249. this.villageGenerator.generate(this, this.worldObj, par1, par2, var3);
  250. this.strongholdGenerator.generate(this, this.worldObj, par1, par2, var3);
  251. this.scatteredFeatureGenerator.generate(this, this.worldObj, par1, par2, var3);
  252. }
  253. Chunk var4 = new Chunk(this.worldObj, var3, par1, par2);
  254. byte[] var5 = var4.getBiomeArray();
  255. for (int var6 = 0; var6 < var5.length; var6++)
  256. {
  257. var5[var6] = ((byte)this.biomesForGeneration[var6].biomeID);
  258. }
  259. var4.generateSkylightMap();
  260. return var4;
  261. }
  262. private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
  263. {
  264. if (par1ArrayOfDouble == null)
  265. {
  266. par1ArrayOfDouble = new double[par5 * par6 * par7];
  267. }
  268. if (this.parabolicField == null)
  269. {
  270. this.parabolicField = new float[25];
  271. for (int var8 = -2; var8 <= 2; var8++)
  272. {
  273. for (int var9 = -2; var9 <= 2; var9++)
  274. {
  275.          float var10 = 10.0F / MathHelper.sqrt_float(var8 * var8 + var9 * var9 + 0.2F);
  276.          this.parabolicField[(var8 + 2 + (var9 + 2) * 5)] = var10;
  277. }
  278. }
  279. }
  280. double var44 = 684.41200000000003D;
  281. double var45 = 684.41200000000003D;
  282. this.noise5 = this.noiseGen5.generateNoiseOctaves(this.noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
  283. this.noise6 = this.noiseGen6.generateNoiseOctaves(this.noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
  284. this.noise3 = this.noiseGen3.generateNoiseOctaves(this.noise3, par2, par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);
  285. this.noise1 = this.noiseGen1.generateNoiseOctaves(this.noise1, par2, par3, par4, par5, par6, par7, var44, var45, var44);
  286. this.noise2 = this.noiseGen2.generateNoiseOctaves(this.noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44);
  287. boolean var43 = false;
  288. boolean var42 = false;
  289. int var12 = 0;
  290. int var13 = 0;
  291. for (int var14 = 0; var14 < par5; var14++)
  292. {
  293. for (int var15 = 0; var15 < par7; var15++)
  294. {
  295. float var16 = 0.0F;
  296. float var17 = 0.0F;
  297. float var18 = 0.0F;
  298. byte var19 = 2;
  299. BiomeGenBase var20 = this.biomesForGeneration[(var14 + 2 + (var15 + 2) * (par5 + 5))];
  300. for (int var21 = -var19; var21 <= var19; var21++)
  301. {
  302.          for (int var22 = -var19; var22 <= var19; var22++)
  303.          {
  304.          BiomeGenBase var23 = this.biomesForGeneration[(var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5))];
  305.          float var24 = this.parabolicField[(var21 + 2 + (var22 + 2) * 5)] / (var23.minHeight + 2.0F);
  306.          if (var23.minHeight > var20.minHeight)
  307.          {
  308.          var24 /= 2.0F;
  309.          }
  310.          var16 += var23.maxHeight * var24;
  311.          var17 += var23.minHeight * var24;
  312.          var18 += var24;
  313.          }
  314. }
  315. var16 /= var18;
  316. var17 /= var18;
  317. var16 = var16 * 0.9F + 0.1F;
  318. var17 = (var17 * 4.0F - 1.0F) / 8.0F;
  319. double var47 = this.noise6[var13] / 8000.0D;
  320. if (var47 < 0.0D)
  321. {
  322.          var47 = -var47 * 0.3D;
  323. }
  324. var47 = var47 * 3.0D - 2.0D;
  325. if (var47 < 0.0D)
  326. {
  327.          var47 /= 2.0D;
  328.          if (var47 < -1.0D)
  329.          {
  330.          var47 = -1.0D;
  331.          }
  332.          var47 /= 1.4D;
  333.          var47 /= 2.0D;
  334. }
  335. else
  336. {
  337.          if (var47 > 1.0D)
  338.          {
  339.          var47 = 1.0D;
  340.          }
  341.          var47 /= 8.0D;
  342. }
  343. var13++;
  344. for (int var46 = 0; var46 < par6; var46++)
  345. {
  346.          double var48 = var17;
  347.          double var26 = var16;
  348.          var48 += var47 * 0.2D;
  349.          var48 = var48 * par6 / 16.0D;
  350.          double var28 = par6 / 2.0D + var48 * 4.0D;
  351.          double var30 = 0.0D;
  352.          double var32 = (var46 - var28) * 12.0D * 128.0D / 128.0D / var26;
  353.          if (var32 < 0.0D)
  354.          {
  355.          var32 *= 4.0D;
  356.          }
  357.          double var34 = this.noise1[var12] / 512.0D;
  358.          double var36 = this.noise2[var12] / 512.0D;
  359.          double var38 = (this.noise3[var12] / 10.0D + 1.0D) / 2.0D;
  360.          if (var38 < 0.0D)
  361.          {
  362.          var30 = var34;
  363.          }
  364.          else if (var38 > 1.0D)
  365.          {
  366.          var30 = var36;
  367.          }
  368.          else
  369.          {
  370.          var30 = var34 + (var36 - var34) * var38;
  371.          }
  372.          var30 -= var32;
  373.          if (var46 > par6 - 4)
  374.          {
  375.          double var40 = (var46 - (par6 - 4)) / 3.0F;
  376.          var30 = var30 * (1.0D - var40) + -10.0D * var40;
  377.          }
  378.          par1ArrayOfDouble[var12] = var30;
  379.          var12++;
  380. }
  381. }
  382. }
  383. return par1ArrayOfDouble;
  384. }
  385. public boolean chunkExists(int par1, int par2)
  386. {
  387. return true;
  388. }
  389. public void populate(IChunkProvider par1IChunkProvider, int par2, int par3)
  390. {
  391. net.minecraft.block.BlockSand.fallInstantly = true;
  392. int var4 = par2 * 16;
  393. int var5 = par3 * 16;
  394. BiomeGenBase var6 = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);
  395. this.rand.setSeed(this.worldObj.getSeed());
  396. long var7 = this.rand.nextLong() / 2L * 2L + 1L;
  397. long var9 = this.rand.nextLong() / 2L * 2L + 1L;
  398. this.rand.setSeed(par2 * var7 + par3 * var9 ^ this.worldObj.getSeed());
  399. boolean var11 = false;
  400. if (this.mapFeaturesEnabled)
  401. {
  402. this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
  403. var11 = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
  404. this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
  405. this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, par2, par3);
  406. }
  407. if ((!var11) && (this.rand.nextInt(4) == 0))
  408. {
  409. int var12 = var4 + this.rand.nextInt(16) + 8;
  410. int var13 = this.rand.nextInt(128);
  411. int var14 = var5 + this.rand.nextInt(16) + 8;
  412. new WorldGenLakes(Block.waterStill.blockID).generate(this.worldObj, this.rand, var12, var13, var14);
  413. }
  414. var6.decorate(this.worldObj, this.rand, var4, var5);
  415. SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4 + 8, var5 + 8, 16, 16, this.rand);
  416. var4 += 8;
  417. var5 += 8;
  418. for (int var12 = 0; var12 < 16; var12++)
  419. {
  420. for (int var13 = 0; var13 < 16; var13++)
  421. {
  422. int var14 = this.worldObj.getPrecipitationHeight(var4 + var12, var5 + var13);
  423. if (this.worldObj.isBlockFreezable(var12 + var4, var14 - 1, var13 + var5))
  424. {
  425.          this.worldObj.setBlock(var12 + var4, var14 - 1, var13 + var5, Block.ice.blockID);
  426. }
  427. if (this.worldObj.canSnowAt(var12 + var4, var14, var13 + var5))
  428. {
  429.          this.worldObj.setBlock(var12 + var4, var14, var13 + var5, Block.snow.blockID);
  430. }
  431. }
  432. }
  433. net.minecraft.block.BlockSand.fallInstantly = false;
  434. }
  435. public boolean saveChunks(boolean par1, IProgressUpdate par2IProgressUpdate)
  436. {
  437. return true;
  438. }
  439. public boolean unload100OldestChunks()
  440. {
  441. return false;
  442. }
  443. public boolean canSave()
  444. {
  445. return true;
  446. }
  447. public String makeString()
  448. {
  449. return "RandomLevelSource";
  450. }
  451. public List getPossibleCreatures(EnumCreatureType par1EnumCreatureType, int par2, int par3, int par4)
  452. {
  453. BiomeGenBase var5 = this.worldObj.getBiomeGenForCoords(par2, par4);
  454. return var5 == null ? null : var5.getSpawnableList(par1EnumCreatureType);
  455. }
  456. public ChunkPosition findClosestStructure(World par1World, String par2Str, int par3, int par4, int par5)
  457. {
  458. return ("Stronghold".equals(par2Str)) && (this.strongholdGenerator != null) ? this.strongholdGenerator.getNearestInstance(par1World, par3, par4, par5) : null;
  459. }
  460. public int getLoadedChunkCount() {
  461. return 0;
  462. }
  463. public boolean unloadQueuedChunks()
  464. {
  465. return false;
  466. }
  467. public void recreateStructures(int i, int j)
  468. {
  469. }
  470. public void func_104112_b() {
  471. // TODO Auto-generated method stub
  472. }
  473. @Override
  474. public ChunkPosition func_147416_a(World p_147416_1_, String p_147416_2_,
  475.         int p_147416_3_, int p_147416_4_, int p_147416_5_) {
  476.     // TODO Auto-generated method stub
  477.     return null;
  478. }
  479. @Override
  480. public void saveExtraData() {
  481.     // TODO Auto-generated method stub
  482.    
  483. }
  484. }
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!