API tools faq
paste
Guest User

LOTRChunkProvider.java

a guest
Jun 8th, 2013
411
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.80 KB | None | 0 0
raw download clone embed print report
  1. package mods.lotr.common;
  2.  
  3. import java.util.List;
  4. import java.util.Random;
  5. import net.minecraft.world.*;
  6. import net.minecraft.world.gen.*;
  7. import net.minecraft.world.gen.feature.*;
  8. import net.minecraft.world.gen.structure.*;
  9. import net.minecraft.world.chunk.*;
  10. import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
  11. import net.minecraft.world.biome.*;
  12. import net.minecraft.block.*;
  13. import net.minecraft.entity.*;
  14. import net.minecraft.util.*;
  15.  
  16. public class LOTRChunkProvider implements IChunkProvider
  17. {
  18. private Random rand;
  19. private NoiseGeneratorOctaves noiseGen1;
  20. private NoiseGeneratorOctaves noiseGen2;
  21. private NoiseGeneratorOctaves noiseGen3;
  22. private NoiseGeneratorOctaves noiseGen4;
  23. private NoiseGeneratorOctaves noiseGen5;
  24. private NoiseGeneratorOctaves noiseGen6;
  25. private World worldObj;
  26. private double[] noiseField;
  27. private double[] stoneNoise = new double[256];
  28. private MapGenBase caveGenerator = new LOTRMapGenCaves();
  29. public static LOTRMapGenDwarvenMine dwarvenMineGenerator = new LOTRMapGenDwarvenMine();
  30. private BiomeGenBase[] biomesForGeneration;
  31. double[] noise3;
  32. double[] noise1;
  33. double[] noise2;
  34. double[] noise5;
  35. double[] noise6;
  36. float[] noiseFloatArray;
  37. int[][] unusedIntArray = new int[32][32];
  38.  
  39. public LOTRChunkProvider(World world, long l)
  40. {
  41. worldObj = world;
  42. rand = new Random(l);
  43. noiseGen1 = new NoiseGeneratorOctaves(rand, 16);
  44. noiseGen2 = new NoiseGeneratorOctaves(rand, 16);
  45. noiseGen3 = new NoiseGeneratorOctaves(rand, 8);
  46. noiseGen4 = new NoiseGeneratorOctaves(rand, 4);
  47. noiseGen5 = new NoiseGeneratorOctaves(rand, 10);
  48. noiseGen6 = new NoiseGeneratorOctaves(rand, 16);
  49. }
  50.  
  51. public void generateTerrain(int i, int j, byte[] byteArray)
  52. {
  53. byte byte0 = 4;
  54. byte byte1 = 32;
  55. byte byte2 = 63;
  56. int k = byte0 + 1;
  57. byte byte3 = 33;
  58. int l = byte0 + 1;
  59. biomesForGeneration = worldObj.getWorldChunkManager().getBiomesForGeneration(biomesForGeneration, i * 4 - 2, j * 4 - 2, k + 5, l + 5);
  60. noiseField = initializeNoiseField(noiseField, i * byte0, 0, j * byte0, k, byte3, l);
  61.  
  62. for (int i1 = 0; i1 < byte0; i1++)
  63. {
  64. for (int j1 = 0; j1 < byte0; j1++)
  65. {
  66. for (int k1 = 0; k1 < byte1; k1++)
  67. {
  68. double d = 0.125D;
  69. double d1 = noiseField[((i1 + 0) * l + j1 + 0) * byte3 + k1 + 0];
  70. double d2 = noiseField[((i1 + 0) * l + j1 + 1) * byte3 + k1 + 0];
  71. double d3 = noiseField[((i1 + 1) * l + j1 + 0) * byte3 + k1 + 0];
  72. double d4 = noiseField[((i1 + 1) * l + j1 + 1) * byte3 + k1 + 0];
  73. double d5 = (noiseField[((i1 + 0) * l + j1 + 0) * byte3 + k1 + 1] - d1) * d;
  74. double d6 = (noiseField[((i1 + 0) * l + j1 + 1) * byte3 + k1 + 1] - d2) * d;
  75. double d7 = (noiseField[((i1 + 1) * l + j1 + 0) * byte3 + k1 + 1] - d3) * d;
  76. double d8 = (noiseField[((i1 + 1) * l + j1 + 1) * byte3 + k1 + 1] - d4) * d;
  77.  
  78. for (int l1 = 0; l1 < 8; ++l1)
  79. {
  80. double d9 = 0.25D;
  81. double d10 = d1;
  82. double d11 = d2;
  83. double d12 = (d3 - d1) * d9;
  84. double d13 = (d4 - d2) * d9;
  85.  
  86. for (int i2 = 0; i2 < 4; ++i2)
  87. {
  88. int j2 = i2 + i1 * 4 << 12 | 0 + j1 * 4 << 8 | k1 * 8 + l1;
  89. short s = 256;
  90. j2 -= s;
  91. double d14 = 0.25D;
  92. double d15 = (d11 - d10) * d14;
  93. double d16 = d10 - d15;
  94.  
  95. for (int k2 = 0; k2 < 4; ++k2)
  96. {
  97. if ((d16 += d15) > 0.0D)
  98. {
  99. byteArray[j2 += s] = (byte)Block.stone.blockID;
  100. }
  101. else if (k1 * 8 + l1 < byte2)
  102. {
  103. byteArray[j2 += s] = (byte)Block.waterStill.blockID;
  104. }
  105. else
  106. {
  107. byteArray[j2 += s] = 0;
  108. }
  109. }
  110.  
  111. d10 += d12;
  112. d11 += d13;
  113. }
  114. d1 += d5;
  115. d2 += d6;
  116. d3 += d7;
  117. d4 += d8;
  118. }
  119. }
  120. }
  121. }
  122. }
  123.  
  124. public void replaceBlocksForBiome(int i, int j, byte[] blocks, byte[] metadata, BiomeGenBase[] biomeArray)
  125. {
  126. byte byte0 = 63;
  127. double d = 0.03125D;
  128. stoneNoise = noiseGen4.generateNoiseOctaves(stoneNoise, i * 16, j * 16, 0, 16, 16, 1, d * 2.0D, d * 2.0D, d * 2.0D);
  129. for (int k = 0; k < 16; ++k)
  130. {
  131. for (int l = 0; l < 16; ++l)
  132. {
  133. BiomeGenBase biomegenbase = biomeArray[l + k * 16];
  134. int i1 = (int)(stoneNoise[k + l * 16] / 3.0D + 3.0D + rand.nextDouble() * 0.25D);
  135. int j1 = -1;
  136. byte byte1 = biomegenbase.topBlock;
  137. byte byte2 = biomegenbase.fillerBlock;
  138. byte byte4 = 0;
  139. for (int k1 = 255; k1 >= 0; --k1)
  140. {
  141. int l1 = (l * 16 + k) * 256 + k1;
  142. if (k1 <= 0 + rand.nextInt(5))
  143. {
  144. blocks[l1] = (byte)Block.bedrock.blockID;
  145. }
  146. else
  147. {
  148. byte byte3 = blocks[l1];
  149. if (byte3 == 0)
  150. {
  151. j1 = -1;
  152. }
  153. else if (byte3 == (byte)Block.stone.blockID)
  154. {
  155. if (j1 == -1)
  156. {
  157. if (i1 <= 0)
  158. {
  159. byte1 = 0;
  160. byte2 = (byte)Block.stone.blockID;
  161. }
  162. else if (k1 >= byte0 - 4 && k1 <= byte0 + 1)
  163. {
  164. byte1 = biomegenbase.topBlock;
  165. byte2 = biomegenbase.fillerBlock;
  166. }
  167. if (k1 < byte0 && byte1 == 0)
  168. {
  169. byte1 = (byte)Block.waterStill.blockID;
  170. }
  171. j1 = i1;
  172. if (k1 >= byte0 - 1)
  173. {
  174. blocks[l1] = byte1;
  175. }
  176. else
  177. {
  178. blocks[l1] = byte2;
  179. metadata[l1] = byte4;
  180. }
  181. }
  182. else if (j1 > 0)
  183. {
  184. --j1;
  185. blocks[l1] = byte2;
  186. metadata[l1] = byte4;
  187.  
  188. if (biomegenbase instanceof LOTRBiomeGenGondor && j1 == 0 && byte2 == Block.dirt.blockID)
  189. {
  190. j1 = 2 + rand.nextInt(3);
  191. byte2 = (byte)LOTRMod.rock.blockID;
  192. byte4 = (byte)1;
  193. }
  194. }
  195. }
  196. }
  197. }
  198.  
  199. if (biomegenbase instanceof LOTRBiomeGenMistyMountains)
  200. {
  201. for (int k1 = 255; k1 >= 96; --k1)
  202. {
  203. int l1 = (l * 16 + k) * 256 + k1;
  204. if (blocks[l1] == (byte)Block.grass.blockID)
  205. {
  206. blocks[l1] = (byte)Block.blockSnow.blockID;
  207. }
  208. }
  209. }
  210.  
  211. if (biomegenbase instanceof LOTRBiomeGenGondorMountains)
  212. {
  213. for (int k1 = 255; k1 >= 80; --k1)
  214. {
  215. int l1 = (l * 16 + k) * 256 + k1;
  216. if (blocks[l1] == (byte)Block.dirt.blockID || blocks[l1] == (byte)Block.grass.blockID)
  217. {
  218. blocks[l1] = (byte)LOTRMod.rock.blockID;
  219. metadata[l1] = (byte)1;
  220. }
  221. }
  222. }
  223.  
  224. if (biomegenbase instanceof LOTRBiomeGenMordor)
  225. {
  226. for (int k1 = 255; k1 >= 0; --k1)
  227. {
  228. int l1 = (l * 16 + k) * 256 + k1;
  229. if (blocks[l1] == (byte)Block.stone.blockID)
  230. {
  231. blocks[l1] = (byte)LOTRMod.rock.blockID;
  232. }
  233. }
  234. }
  235. }
  236. }
  237. }
  238.  
  239. @Override
  240. public Chunk loadChunk(int i, int j)
  241. {
  242. return provideChunk(i, j);
  243. }
  244.  
  245. @Override
  246. public Chunk provideChunk(int i, int j)
  247. {
  248. rand.setSeed((long)i * 341873128712L + (long)j * 132897987541L);
  249. byte[] blocks = new byte[65536];
  250. byte[] metadata = new byte[65536];
  251. generateTerrain(i, j, blocks);
  252. biomesForGeneration = worldObj.getWorldChunkManager().loadBlockGeneratorData(biomesForGeneration, i * 16, j * 16, 16, 16);
  253. replaceBlocksForBiome(i, j, blocks, metadata, biomesForGeneration);
  254. caveGenerator.generate(this, worldObj, i, j, blocks);
  255.  
  256. dwarvenMineGenerator.generate(this, worldObj, i, j, blocks);
  257.  
  258. Chunk chunk = new Chunk(worldObj, i, j);
  259. ExtendedBlockStorage blockStorage[] = chunk.getBlockStorageArray();
  260.  
  261. byte[] biomes = chunk.getBiomeArray();
  262. for (int k = 0; k < biomes.length; k++)
  263. {
  264. biomes[k] = (byte)biomesForGeneration[k].biomeID;
  265. }
  266.  
  267. for (int i1 = 0; i1 < 16; i1++)
  268. {
  269. for (int k1 = 0; k1 < 16; k1++)
  270. {
  271. for (int j1 = 0; j1 < 256; j1++)
  272. {
  273. byte id = blocks[i1 << 12 | k1 << 8 | j1];
  274. byte meta = metadata[i1 << 12 | k1 << 8 | j1];
  275.  
  276. if (id == 0)
  277. {
  278. continue;
  279. }
  280.  
  281. int j2 = j1 >> 4;
  282.  
  283. if (blockStorage[j2] == null)
  284. {
  285. blockStorage[j2] = new ExtendedBlockStorage(j2 << 4, true);
  286. }
  287.  
  288. blockStorage[j2].setExtBlockID(i1, j1 & 15, k1, id & 255);
  289. blockStorage[j2].setExtBlockMetadata(i1, j1 & 15, k1, meta & 15);
  290. }
  291. }
  292. }
  293.  
  294. chunk.generateSkylightMap();
  295. return chunk;
  296. }
  297.  
  298. private double[] initializeNoiseField(double[] par1ArrayOfDouble, int par2, int par3, int par4, int par5, int par6, int par7)
  299. {
  300. if (par1ArrayOfDouble == null)
  301. {
  302. par1ArrayOfDouble = new double[par5 * par6 * par7];
  303. }
  304. if (noiseFloatArray == null)
  305. {
  306. noiseFloatArray = new float[25];
  307.  
  308. for (int var8 = -2; var8 <= 2; ++var8)
  309. {
  310. for (int var9 = -2; var9 <= 2; ++var9)
  311. {
  312. float var10 = 10.0F / MathHelper.sqrt_float((float)(var8 * var8 + var9 * var9) + 0.2F);
  313. noiseFloatArray[var8 + 2 + (var9 + 2) * 5] = var10;
  314. }
  315. }
  316. }
  317. double var44 = 684.412D;
  318. double var45 = 684.412D;
  319. noise5 = noiseGen5.generateNoiseOctaves(noise5, par2, par4, par5, par7, 1.121D, 1.121D, 0.5D);
  320. noise6 = noiseGen6.generateNoiseOctaves(noise6, par2, par4, par5, par7, 200.0D, 200.0D, 0.5D);
  321. noise3 = noiseGen3.generateNoiseOctaves(noise3, par2, par3, par4, par5, par6, par7, var44 / 80.0D, var45 / 160.0D, var44 / 80.0D);
  322. noise1 = noiseGen1.generateNoiseOctaves(noise1, par2, par3, par4, par5, par6, par7, var44, var45, var44);
  323. noise2 = noiseGen2.generateNoiseOctaves(noise2, par2, par3, par4, par5, par6, par7, var44, var45, var44);
  324. boolean var43 = false;
  325. boolean var42 = false;
  326. int var12 = 0;
  327. int var13 = 0;
  328.  
  329. for (int var14 = 0; var14 < par5; ++var14)
  330. {
  331. for (int var15 = 0; var15 < par7; ++var15)
  332. {
  333. float var16 = 0.0F;
  334. float var17 = 0.0F;
  335. float var18 = 0.0F;
  336. byte var19 = 2;
  337. BiomeGenBase var20 = biomesForGeneration[var14 + 2 + (var15 + 2) * (par5 + 5)];
  338.  
  339. for (int var21 = -var19; var21 <= var19; ++var21)
  340. {
  341. for (int var22 = -var19; var22 <= var19; ++var22)
  342. {
  343. BiomeGenBase var23 = biomesForGeneration[var14 + var21 + 2 + (var15 + var22 + 2) * (par5 + 5)];
  344. float var24 = noiseFloatArray[var21 + 2 + (var22 + 2) * 5] / (var23.minHeight + 2.0F) / 2F;
  345.  
  346. if (var23.minHeight > var20.minHeight)
  347. {
  348. var24 /= 2.0F;
  349. }
  350.  
  351. var16 += var23.maxHeight * var24;
  352. var17 += var23.minHeight * var24;
  353. var18 += var24;
  354. }
  355. }
  356. var16 /= var18;
  357. var17 /= var18;
  358. var16 = var16 * 0.9F + 0.1F;
  359. var17 = (var17 * 4.0F - 1.0F) / 8.0F;
  360. double var47 = noise6[var13] / 8000.0D;
  361. if (var47 < 0.0D)
  362. {
  363. var47 = -var47 * 0.3D;
  364. }
  365. var47 = var47 * 3.0D - 2.0D;
  366. if (var47 < 0.0D)
  367. {
  368. var47 /= 2.0D;
  369. if (var47 < -1.0D)
  370. {
  371. var47 = -1.0D;
  372. }
  373. var47 /= 1.4D;
  374. var47 /= 2.0D;
  375. }
  376. else
  377. {
  378. if (var47 > 1.0D)
  379. {
  380. var47 = 1.0D;
  381. }
  382. var47 /= 8.0D;
  383. }
  384. ++var13;
  385. for (int var46 = 0; var46 < par6; ++var46)
  386. {
  387. double var48 = (double)var17;
  388. double var26 = (double)var16;
  389. var48 += var47 * 0.2D;
  390. var48 = var48 * (double)par6 / 16.0D;
  391. double var28 = (double)par6 / 2.0D + var48 * 4.0D;
  392. double var30 = 0.0D;
  393. double var32 = ((double)var46 - var28) * 12.0D * 128.0D / 256.0D / var26;
  394. if (var32 < 0.0D)
  395. {
  396. var32 *= 4.0D;
  397. }
  398. double var34 = noise1[var12] / 512.0D;
  399. double var36 = noise2[var12] / 512.0D;
  400. double var38 = (noise3[var12] / 10.0D + 1.0D) / 2.0D;
  401. if (var38 < 0.0D)
  402. {
  403. var30 = var34;
  404. }
  405. else if (var38 > 1.0D)
  406. {
  407. var30 = var36;
  408. }
  409. else
  410. {
  411. var30 = var34 + (var36 - var34) * var38;
  412. }
  413. var30 -= var32;
  414. if (var46 > par6 - 4)
  415. {
  416. double var40 = (double)((float)(var46 - (par6 - 4)) / 3.0F);
  417. var30 = var30 * (1.0D - var40) + -10.0D * var40;
  418. }
  419. par1ArrayOfDouble[var12] = var30;
  420. ++var12;
  421. }
  422. }
  423. }
  424. return par1ArrayOfDouble;
  425. }
  426.  
  427. @Override
  428. public boolean chunkExists(int i, int j)
  429. {
  430. return true;
  431. }
  432.  
  433. @Override
  434. public void populate(IChunkProvider ichunkprovider, int i, int j)
  435. {
  436. BlockSand.fallInstantly = true;
  437. int k = i * 16;
  438. int l = j * 16;
  439. BiomeGenBase biomegenbase = worldObj.getBiomeGenForCoords(k + 16, l + 16);
  440. LOTRBiome biome;
  441. if (biomegenbase instanceof LOTRBiome)
  442. {
  443. biome = (LOTRBiome)biomegenbase;
  444. }
  445. else
  446. {
  447. return;
  448. }
  449. rand.setSeed(worldObj.getSeed());
  450. long l1 = (rand.nextLong() / 2L) * 2L + 1L;
  451. long l2 = (rand.nextLong() / 2L) * 2L + 1L;
  452. rand.setSeed((long)i * l1 + (long)j * l2 ^ worldObj.getSeed());
  453.  
  454. dwarvenMineGenerator.generateStructuresInChunk(worldObj, rand, i, j);
  455.  
  456. if (rand.nextInt(4) == 0)
  457. {
  458. int i1 = k + rand.nextInt(16) + 8;
  459. int j2 = rand.nextInt(128);
  460. int k3 = l + rand.nextInt(16) + 8;
  461.  
  462. if (j2 < 60 || rand.nextFloat() < biome.getChanceToSpawnLakes())
  463. {
  464. (new WorldGenLakes(Block.waterStill.blockID)).generate(worldObj, rand, i1, j2, k3);
  465. }
  466. }
  467.  
  468. if (rand.nextInt(8) == 0)
  469. {
  470. int i1 = k + rand.nextInt(16) + 8;
  471. int j1 = rand.nextInt(rand.nextInt(120) + 8);
  472. int k1 = l + rand.nextInt(16) + 8;
  473.  
  474. if (j1 < 60 || rand.nextFloat() < biome.getChanceToSpawnLavaLakes())
  475. {
  476. (new WorldGenLakes(Block.lavaStill.blockID)).generate(worldObj, rand, i1, j1, k1);
  477. }
  478. }
  479.  
  480. biome.decorate(worldObj, rand, k, l);
  481.  
  482. if (biome.getChanceToSpawnAnimals() <= 1F)
  483. {
  484. if (rand.nextFloat() < biome.getChanceToSpawnAnimals())
  485. {
  486. SpawnerAnimals.performWorldGenSpawning(worldObj, biome, k + 8, l + 8, 16, 16, rand);
  487. }
  488. }
  489. else
  490. {
  491. for (int i1 = 0; i1 < MathHelper.floor_double(biome.getChanceToSpawnAnimals()); i1++)
  492. {
  493. SpawnerAnimals.performWorldGenSpawning(worldObj, biome, k + 8, l + 8, 16, 16, rand);
  494. }
  495. }
  496.  
  497. k += 8;
  498. l += 8;
  499.  
  500. for (int i1 = 0; i1 < 16; i1++)
  501. {
  502. for (int k1 = 0; k1 < 16; k1++)
  503. {
  504. int j1 = worldObj.getPrecipitationHeight(k + i1, l + k1);
  505.  
  506. if (worldObj.isBlockFreezable(i1 + k, j1 - 1, k1 + l))
  507. {
  508. worldObj.setBlock(i1 + k, j1 - 1, k1 + l, Block.ice.blockID, 0, 2);
  509. }
  510.  
  511. if (worldObj.canSnowAt(i1 + k, j1, k1 + l))
  512. {
  513. worldObj.setBlock(i1 + k, j1, k1 + l, Block.snow.blockID, 0, 2);
  514. }
  515. }
  516. }
  517.  
  518. BlockSand.fallInstantly = false;
  519. }
  520.  
  521. @Override
  522. public boolean saveChunks(boolean flag, IProgressUpdate update)
  523. {
  524. return true;
  525. }
  526.  
  527. @Override
  528. public void func_104112_b() {}
  529.  
  530. @Override
  531. public boolean unloadQueuedChunks()
  532. {
  533. return false;
  534. }
  535.  
  536. @Override
  537. public boolean canSave()
  538. {
  539. return true;
  540. }
  541.  
  542. @Override
  543. public String makeString()
  544. {
  545. return "MiddleEarthLevelSource";
  546. }
  547.  
  548. @Override
  549. public List getPossibleCreatures(EnumCreatureType creatureType, int i, int j, int k)
  550. {
  551. BiomeGenBase biome = worldObj.getBiomeGenForCoords(i, k);
  552. return biome == null ? null : biome.getSpawnableList(creatureType);
  553. }
  554.  
  555. @Override
  556. public ChunkPosition findClosestStructure(World world, String s, int i, int j, int k)
  557. {
  558. return null;
  559. }
  560.  
  561. @Override
  562. public int getLoadedChunkCount()
  563. {
  564. return 0;
  565. }
  566.  
  567. @Override
  568. public void recreateStructures(int i, int j)
  569. {
  570. dwarvenMineGenerator.generate(this, worldObj, i, j, null);
  571. }
  572. }
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!