API tools faq
paste
Advertisement
Guest User

ChunkProviderVoid.java

a guest
Aug 28th, 2011
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.59 KB | None | 0 0
raw download clone embed print report
  1. package net.minecraft.src;
  2.  
  3. import java.util.Random;
  4.  
  5.  
  6. public class ChunkProviderVoid
  7. implements IChunkProvider
  8. {
  9.  
  10. public ChunkProviderVoid(World world, long l)
  11. {
  12. field_28079_r = new double[256];
  13. field_28078_s = new double[256];
  14. field_28077_t = new double[256];
  15. field_28076_u = new MapGenCavesVoid();
  16. field_28088_i = new int[32][32];
  17. field_28081_p = world;
  18. field_28087_j = new Random(l);
  19. field_28086_k = new NoiseGeneratorOctaves(field_28087_j, 16);
  20. field_28085_l = new NoiseGeneratorOctaves(field_28087_j, 16);
  21. field_28084_m = new NoiseGeneratorOctaves(field_28087_j, 8);
  22. field_28083_n = new NoiseGeneratorOctaves(field_28087_j, 4);
  23. field_28082_o = new NoiseGeneratorOctaves(field_28087_j, 4);
  24. field_28096_a = new NoiseGeneratorOctaves(field_28087_j, 10);
  25. field_28095_b = new NoiseGeneratorOctaves(field_28087_j, 16);
  26. field_28094_c = new NoiseGeneratorOctaves(field_28087_j, 8);
  27. }
  28.  
  29. public void func_28071_a(int i, int j, byte abyte0[], BiomeGenBase abiomegenbase[], double ad[])
  30. {
  31. byte byte0 = 2;
  32. int k = byte0 + 1;
  33. byte byte1 = 33;
  34. int l = byte0 + 1;
  35. field_28080_q = func_28073_a(field_28080_q, i * byte0, 0, j * byte0, k, byte1, l);
  36. for(int i1 = 0; i1 < byte0; i1++)
  37. {
  38. for(int j1 = 0; j1 < byte0; j1++)
  39. {
  40. for(int k1 = 0; k1 < 32; k1++)
  41. {
  42. double d = 0.25D;
  43. double d1 = field_28080_q[((i1 + 0) * l + (j1 + 0)) * byte1 + (k1 + 0)];
  44. double d2 = field_28080_q[((i1 + 0) * l + (j1 + 1)) * byte1 + (k1 + 0)];
  45. double d3 = field_28080_q[((i1 + 1) * l + (j1 + 0)) * byte1 + (k1 + 0)];
  46. double d4 = field_28080_q[((i1 + 1) * l + (j1 + 1)) * byte1 + (k1 + 0)];
  47. double d5 = (field_28080_q[((i1 + 0) * l + (j1 + 0)) * byte1 + (k1 + 1)] - d1) * d;
  48. double d6 = (field_28080_q[((i1 + 0) * l + (j1 + 1)) * byte1 + (k1 + 1)] - d2) * d;
  49. double d7 = (field_28080_q[((i1 + 1) * l + (j1 + 0)) * byte1 + (k1 + 1)] - d3) * d;
  50. double d8 = (field_28080_q[((i1 + 1) * l + (j1 + 1)) * byte1 + (k1 + 1)] - d4) * d;
  51. for(int l1 = 0; l1 < 4; l1++)
  52. {
  53. double d9 = 0.125D;
  54. double d10 = d1;
  55. double d11 = d2;
  56. double d12 = (d3 - d1) * d9;
  57. double d13 = (d4 - d2) * d9;
  58. for(int i2 = 0; i2 < 8; i2++)
  59. {
  60. int j2 = i2 + i1 * 8 << 11 | 0 + j1 * 8 << 7 | k1 * 4 + l1;
  61. char c = '\200';
  62. double d14 = 0.125D;
  63. double d15 = d10;
  64. double d16 = (d11 - d10) * d14;
  65. for(int k2 = 0; k2 < 8; k2++)
  66. {
  67. int l2 = 0;
  68. if(d15 > 0.0D)
  69. {
  70. l2 = mod_Void.VoidStone.blockID;
  71. }
  72. abyte0[j2] = (byte)l2;
  73. j2 += c;
  74. d15 += d16;
  75. }
  76.  
  77. d10 += d12;
  78. d11 += d13;
  79. }
  80.  
  81. d1 += d5;
  82. d2 += d6;
  83. d3 += d7;
  84. d4 += d8;
  85. }
  86.  
  87. }
  88.  
  89. }
  90.  
  91. }
  92.  
  93. }
  94.  
  95. public void func_28072_a(int i, int j, byte abyte0[], BiomeGenBase abiomegenbase[])
  96. {
  97. double d = 0.03125D;
  98. field_28079_r = field_28083_n.generateNoiseOctaves(field_28079_r, i * 16, j * 16, 0.0D, 16, 16, 1, d, d, 1.0D);
  99. field_28078_s = field_28083_n.generateNoiseOctaves(field_28078_s, i * 16, 109.0134D, j * 16, 16, 1, 16, d, 1.0D, d);
  100. field_28077_t = field_28082_o.generateNoiseOctaves(field_28077_t, i * 16, j * 16, 0.0D, 16, 16, 1, d * 2D, d * 2D, d * 2D);
  101. for(int k = 0; k < 16; k++)
  102. {
  103. for(int l = 0; l < 16; l++)
  104. {
  105. BiomeGenBase biomegenbase = abiomegenbase[k + l * 16];
  106. int i1 = (int)(field_28077_t[k + l * 16] / 3D + 3D + field_28087_j.nextDouble() * 0.25D);
  107. int j1 = -1;
  108. byte byte0 = (byte)mod_Void.VoidGrass.blockID;
  109. byte byte1 = (byte)mod_Void.VoidDirt.blockID;
  110. for(int k1 = 127; k1 >= 0; k1--)
  111. {
  112. int l1 = (l * 16 + k) * 128 + k1;
  113. byte byte2 = abyte0[l1];
  114. if(byte2 == 0)
  115. {
  116. j1 = -1;
  117. continue;
  118. }
  119. if(byte2 != (byte)mod_Void.VoidStone.blockID)
  120. {
  121. continue;
  122. }
  123. if(j1 == -1)
  124. {
  125. if(i1 <= 0)
  126. {
  127. byte0 = 0;
  128. byte1 = (byte)mod_Void.VoidStone.blockID;
  129. }
  130. j1 = i1;
  131. if(k1 >= 0)
  132. {
  133. abyte0[l1] = byte0;
  134. } else
  135. {
  136. abyte0[l1] = byte1;
  137. }
  138. continue;
  139. }
  140. if(j1 <= 0)
  141. {
  142. continue;
  143. }
  144. j1--;
  145. abyte0[l1] = byte1;
  146. if(j1 == 0 && byte1 == Block.sand.blockID)
  147. {
  148. j1 = field_28087_j.nextInt(4);
  149. byte1 = (byte)Block.sandStone.blockID;
  150. }
  151. }
  152.  
  153. }
  154.  
  155. }
  156.  
  157. }
  158.  
  159. public Chunk prepareChunk(int i, int j)
  160. {
  161. return provideChunk(i, j);
  162. }
  163.  
  164. public Chunk provideChunk(int i, int j)
  165. {
  166. field_28087_j.setSeed((long)i * 0x4f9939f508L + (long)j * 0x1ef1565bd5L);
  167. byte abyte0[] = new byte[32768];
  168. Chunk chunk = new Chunk(field_28081_p, abyte0, i, j);
  169. field_28075_v = field_28081_p.getWorldChunkManager().loadBlockGeneratorData(field_28075_v, i * 16, j * 16, 16, 16);
  170. double ad[] = field_28081_p.getWorldChunkManager().temperature;
  171. func_28071_a(i, j, abyte0, field_28075_v, ad);
  172. func_28072_a(i, j, abyte0, field_28075_v);
  173. field_28076_u.func_867_a(this, field_28081_p, i, j, abyte0);
  174. chunk.func_1024_c();
  175. return chunk;
  176. }
  177.  
  178. private double[] func_28073_a(double ad[], int i, int j, int k, int l, int i1, int j1)
  179. {
  180. if(ad == null)
  181. {
  182. ad = new double[l * i1 * j1];
  183. }
  184. double d = 684.41200000000003D;
  185. double d1 = 684.41200000000003D;
  186. double ad1[] = field_28081_p.getWorldChunkManager().temperature;
  187. double ad2[] = field_28081_p.getWorldChunkManager().humidity;
  188. field_28090_g = field_28096_a.func_4109_a(field_28090_g, i, k, l, j1, 1.121D, 1.121D, 0.5D);
  189. field_28089_h = field_28095_b.func_4109_a(field_28089_h, i, k, l, j1, 200D, 200D, 0.5D);
  190. d *= 2D;
  191. field_28093_d = field_28084_m.generateNoiseOctaves(field_28093_d, i, j, k, l, i1, j1, d / 80D, d1 / 160D, d / 80D);
  192. field_28092_e = field_28086_k.generateNoiseOctaves(field_28092_e, i, j, k, l, i1, j1, d, d1, d);
  193. field_28091_f = field_28085_l.generateNoiseOctaves(field_28091_f, i, j, k, l, i1, j1, d, d1, d);
  194. int k1 = 0;
  195. int l1 = 0;
  196. int i2 = 16 / l;
  197. for(int j2 = 0; j2 < l; j2++)
  198. {
  199. int k2 = j2 * i2 + i2 / 2;
  200. for(int l2 = 0; l2 < j1; l2++)
  201. {
  202. int i3 = l2 * i2 + i2 / 2;
  203. double d2 = ad1[k2 * 16 + i3];
  204. double d3 = ad2[k2 * 16 + i3] * d2;
  205. double d4 = 1.0D - d3;
  206. d4 *= d4;
  207. d4 *= d4;
  208. d4 = 1.0D - d4;
  209. double d5 = (field_28090_g[l1] + 256D) / 512D;
  210. d5 *= d4;
  211. if(d5 > 1.0D)
  212. {
  213. d5 = 1.0D;
  214. }
  215. double d6 = field_28089_h[l1] / 8000D;
  216. if(d6 < 0.0D)
  217. {
  218. d6 = -d6 * 0.29999999999999999D;
  219. }
  220. d6 = d6 * 3D - 2D;
  221. if(d6 > 1.0D)
  222. {
  223. d6 = 1.0D;
  224. }
  225. d6 /= 8D;
  226. d6 = 0.0D;
  227. if(d5 < 0.0D)
  228. {
  229. d5 = 0.0D;
  230. }
  231. d5 += 0.5D;
  232. d6 = (d6 * (double)i1) / 16D;
  233. l1++;
  234. double d7 = (double)i1 / 2D;
  235. for(int j3 = 0; j3 < i1; j3++)
  236. {
  237. double d8 = 0.0D;
  238. double d9 = (((double)j3 - d7) * 8D) / d5;
  239. if(d9 < 0.0D)
  240. {
  241. d9 *= -1D;
  242. }
  243. double d10 = field_28092_e[k1] / 512D;
  244. double d11 = field_28091_f[k1] / 512D;
  245. double d12 = (field_28093_d[k1] / 10D + 1.0D) / 2D;
  246. if(d12 < 0.0D)
  247. {
  248. d8 = d10;
  249. } else
  250. if(d12 > 1.0D)
  251. {
  252. d8 = d11;
  253. } else
  254. {
  255. d8 = d10 + (d11 - d10) * d12;
  256. }
  257. d8 -= 8D;
  258. int k3 = 32;
  259. if(j3 > i1 - k3)
  260. {
  261. double d13 = (float)(j3 - (i1 - k3)) / ((float)k3 - 1.0F);
  262. d8 = d8 * (1.0D - d13) + -30D * d13;
  263. }
  264. k3 = 8;
  265. if(j3 < k3)
  266. {
  267. double d14 = (float)(k3 - j3) / ((float)k3 - 1.0F);
  268. d8 = d8 * (1.0D - d14) + -30D * d14;
  269. }
  270. ad[k1] = d8;
  271. k1++;
  272. }
  273.  
  274. }
  275.  
  276. }
  277.  
  278. return ad;
  279. }
  280.  
  281. public boolean chunkExists(int i, int j)
  282. {
  283. return true;
  284. }
  285.  
  286. public void populate(IChunkProvider ichunkprovider, int i, int j)
  287. {
  288. BlockSand.fallInstantly = true;
  289. int k = i * 16;
  290. int l = j * 16;
  291. BiomeGenBase biomegenbase = field_28081_p.getWorldChunkManager().getBiomeGenAt(k + 16, l + 16);
  292. field_28087_j.setSeed(field_28081_p.getRandomSeed());
  293. long l1 = (field_28087_j.nextLong() / 2L) * 2L + 1L;
  294. long l2 = (field_28087_j.nextLong() / 2L) * 2L + 1L;
  295. field_28087_j.setSeed((long)i * l1 + (long)j * l2 ^ field_28081_p.getRandomSeed());
  296. double d = 0.25D;
  297. if(field_28087_j.nextInt(4) == 0)
  298. {
  299. int i1 = k + field_28087_j.nextInt(16) + 8;
  300. int l4 = field_28087_j.nextInt(128);
  301. int i8 = l + field_28087_j.nextInt(16) + 8;
  302. (new WorldGenLakes(Block.waterStill.blockID)).generate(field_28081_p, field_28087_j, i1, l4, i8);
  303. }
  304. if(field_28087_j.nextInt(8) == 0)
  305. {
  306. int j1 = k + field_28087_j.nextInt(16) + 8;
  307. int i5 = field_28087_j.nextInt(field_28087_j.nextInt(120) + 8);
  308. int j8 = l + field_28087_j.nextInt(16) + 8;
  309. if(i5 < 64 || field_28087_j.nextInt(10) == 0)
  310. {
  311. (new WorldGenLakes(Block.lavaStill.blockID)).generate(field_28081_p, field_28087_j, j1, i5, j8);
  312. }
  313. }
  314. for(int k1 = 0; k1 < 8; k1++)
  315. {
  316. int j5 = k + field_28087_j.nextInt(16) + 8;
  317. int k8 = field_28087_j.nextInt(128);
  318. int i13 = l + field_28087_j.nextInt(16) + 8;
  319. (new WorldGenDungeons()).generate(field_28081_p, field_28087_j, j5, k8, i13);
  320. }
  321.  
  322. for(int i2 = 0; i2 < 10; i2++)
  323. {
  324. int k5 = k + field_28087_j.nextInt(16);
  325. int l8 = field_28087_j.nextInt(128);
  326. int j13 = l + field_28087_j.nextInt(16);
  327. (new WorldGenClay(32)).generate(field_28081_p, field_28087_j, k5, l8, j13);
  328. }
  329.  
  330. for(int j2 = 0; j2 < 20; j2++)
  331. {
  332. int l5 = k + field_28087_j.nextInt(16);
  333. int i9 = field_28087_j.nextInt(128);
  334. int k13 = l + field_28087_j.nextInt(16);
  335. (new WorldGenMinable(Block.dirt.blockID, 32)).generate(field_28081_p, field_28087_j, l5, i9, k13);
  336. }
  337.  
  338. for(int k2 = 0; k2 < 10; k2++)
  339. {
  340. int i6 = k + field_28087_j.nextInt(16);
  341. int j9 = field_28087_j.nextInt(128);
  342. int l13 = l + field_28087_j.nextInt(16);
  343. (new WorldGenMinable(Block.gravel.blockID, 32)).generate(field_28081_p, field_28087_j, i6, j9, l13);
  344. }
  345.  
  346. for(int i3 = 0; i3 < 20; i3++)
  347. {
  348. int j6 = k + field_28087_j.nextInt(16);
  349. int k9 = field_28087_j.nextInt(128);
  350. int i14 = l + field_28087_j.nextInt(16);
  351. (new WorldGenMinable(Block.oreCoal.blockID, 16)).generate(field_28081_p, field_28087_j, j6, k9, i14);
  352. }
  353.  
  354. for(int j3 = 0; j3 < 20; j3++)
  355. {
  356. int k6 = k + field_28087_j.nextInt(16);
  357. int l9 = field_28087_j.nextInt(64);
  358. int j14 = l + field_28087_j.nextInt(16);
  359. (new WorldGenMinable(Block.oreIron.blockID, 8)).generate(field_28081_p, field_28087_j, k6, l9, j14);
  360. }
  361.  
  362. for(int k3 = 0; k3 < 2; k3++)
  363. {
  364. int l6 = k + field_28087_j.nextInt(16);
  365. int i10 = field_28087_j.nextInt(32);
  366. int k14 = l + field_28087_j.nextInt(16);
  367. (new WorldGenMinable(Block.oreGold.blockID, 8)).generate(field_28081_p, field_28087_j, l6, i10, k14);
  368. }
  369.  
  370. for(int l3 = 0; l3 < 8; l3++)
  371. {
  372. int i7 = k + field_28087_j.nextInt(16);
  373. int j10 = field_28087_j.nextInt(16);
  374. int l14 = l + field_28087_j.nextInt(16);
  375. (new WorldGenMinable(Block.oreRedstone.blockID, 7)).generate(field_28081_p, field_28087_j, i7, j10, l14);
  376. }
  377.  
  378. for(int i4 = 0; i4 < 1; i4++)
  379. {
  380. int j7 = k + field_28087_j.nextInt(16);
  381. int k10 = field_28087_j.nextInt(16);
  382. int i15 = l + field_28087_j.nextInt(16);
  383. (new WorldGenMinable(Block.oreDiamond.blockID, 7)).generate(field_28081_p, field_28087_j, j7, k10, i15);
  384. }
  385.  
  386. for(int j4 = 0; j4 < 1; j4++)
  387. {
  388. int k7 = k + field_28087_j.nextInt(16);
  389. int l10 = field_28087_j.nextInt(16) + field_28087_j.nextInt(16);
  390. int j15 = l + field_28087_j.nextInt(16);
  391. (new WorldGenMinable(Block.oreLapis.blockID, 6)).generate(field_28081_p, field_28087_j, k7, l10, j15);
  392. }
  393.  
  394. d = 0.5D;
  395. int k4 = (int)((field_28094_c.func_806_a((double)k * d, (double)l * d) / 8D + field_28087_j.nextDouble() * 4D + 4D) / 3D);
  396. int l7 = 0;
  397. if(field_28087_j.nextInt(10) == 0)
  398. {
  399. l7++;
  400. }
  401. if(biomegenbase == BiomeGenBase.forest)
  402. {
  403. l7 += k4 + 5;
  404. }
  405. if(biomegenbase == BiomeGenBase.rainforest)
  406. {
  407. l7 += k4 + 5;
  408. }
  409. if(biomegenbase == BiomeGenBase.seasonalForest)
  410. {
  411. //l7 += k4 + 2;
  412. l7 += k4 + 5;
  413. }
  414. if(biomegenbase == BiomeGenBase.taiga)
  415. {
  416. l7 += k4 + 5;
  417. }
  418. if(biomegenbase == BiomeGenBase.desert)
  419. {
  420. //l7 -= 20;
  421. l7 += k4 + 5;
  422. }
  423. if(biomegenbase == BiomeGenBase.tundra)
  424. {
  425. //l7 -= 20;
  426. l7 += k4 + 5;
  427. }
  428. if(biomegenbase == BiomeGenBase.plains)
  429. {
  430. //l7 -= 20;
  431. l7 += k4 + 5;
  432. }
  433. for(int i11 = 0; i11 < l7; i11++)
  434. {
  435. int k15 = k + field_28087_j.nextInt(16) + 8;
  436. int j18 = l + field_28087_j.nextInt(16) + 8;
  437. WorldGenerator worldgenerator = biomegenbase.getRandomWorldGenForTrees(field_28087_j);
  438. worldgenerator.func_517_a(1.0D, 1.0D, 1.0D);
  439. worldgenerator.generate(field_28081_p, field_28087_j, k15, field_28081_p.getHeightValue(k15, j18), j18);
  440. }
  441. for(int i11 = 0; i11 < l7; i11++){
  442. int k15 = k + field_28087_j.nextInt(16) + 8;
  443. int j18 = l + field_28087_j.nextInt(16) + 8;
  444. WorldGenTreesVoid treeGen = new WorldGenTreesVoid();
  445. treeGen.generate(field_28081_p, field_28087_j, k15, field_28081_p.getHeightValue(k15, j18), j18);
  446. }
  447.  
  448. for(int j11 = 0; j11 < 2; j11++)
  449. {
  450. int l15 = k + field_28087_j.nextInt(16) + 8;
  451. int k18 = field_28087_j.nextInt(128);
  452. int i21 = l + field_28087_j.nextInt(16) + 8;
  453. (new WorldGenFlowers(Block.plantYellow.blockID)).generate(field_28081_p, field_28087_j, l15, k18, i21);
  454. }
  455.  
  456. if(field_28087_j.nextInt(2) == 0)
  457. {
  458. int k11 = k + field_28087_j.nextInt(16) + 8;
  459. int i16 = field_28087_j.nextInt(128);
  460. int l18 = l + field_28087_j.nextInt(16) + 8;
  461. (new WorldGenFlowers(Block.plantRed.blockID)).generate(field_28081_p, field_28087_j, k11, i16, l18);
  462. }
  463. if(field_28087_j.nextInt(4) == 0)
  464. {
  465. int l11 = k + field_28087_j.nextInt(16) + 8;
  466. int j16 = field_28087_j.nextInt(128);
  467. int i19 = l + field_28087_j.nextInt(16) + 8;
  468. (new WorldGenFlowers(Block.mushroomBrown.blockID)).generate(field_28081_p, field_28087_j, l11, j16, i19);
  469. }
  470. if(field_28087_j.nextInt(8) == 0)
  471. {
  472. int i12 = k + field_28087_j.nextInt(16) + 8;
  473. int k16 = field_28087_j.nextInt(128);
  474. int j19 = l + field_28087_j.nextInt(16) + 8;
  475. (new WorldGenFlowers(Block.mushroomRed.blockID)).generate(field_28081_p, field_28087_j, i12, k16, j19);
  476. }
  477. for(int j12 = 0; j12 < 10; j12++)
  478. {
  479. int l16 = k + field_28087_j.nextInt(16) + 8;
  480. int k19 = field_28087_j.nextInt(128);
  481. int j21 = l + field_28087_j.nextInt(16) + 8;
  482. (new WorldGenReed()).generate(field_28081_p, field_28087_j, l16, k19, j21);
  483. }
  484.  
  485. if(field_28087_j.nextInt(32) == 0)
  486. {
  487. int k12 = k + field_28087_j.nextInt(16) + 8;
  488. int i17 = field_28087_j.nextInt(128);
  489. int l19 = l + field_28087_j.nextInt(16) + 8;
  490. (new WorldGenPumpkin()).generate(field_28081_p, field_28087_j, k12, i17, l19);
  491. }
  492. int l12 = 0;
  493. if(biomegenbase == BiomeGenBase.desert)
  494. {
  495. l12 += 10;
  496. }
  497. for(int j17 = 0; j17 < l12; j17++)
  498. {
  499. int i20 = k + field_28087_j.nextInt(16) + 8;
  500. int k21 = field_28087_j.nextInt(128);
  501. int k22 = l + field_28087_j.nextInt(16) + 8;
  502. (new WorldGenCactus()).generate(field_28081_p, field_28087_j, i20, k21, k22);
  503. }
  504.  
  505. for(int k17 = 0; k17 < 50; k17++)
  506. {
  507. int j20 = k + field_28087_j.nextInt(16) + 8;
  508. int l21 = field_28087_j.nextInt(field_28087_j.nextInt(120) + 8);
  509. int l22 = l + field_28087_j.nextInt(16) + 8;
  510. (new WorldGenLiquids(Block.waterMoving.blockID)).generate(field_28081_p, field_28087_j, j20, l21, l22);
  511. }
  512.  
  513. for(int l17 = 0; l17 < 20; l17++)
  514. {
  515. int k20 = k + field_28087_j.nextInt(16) + 8;
  516. int i22 = field_28087_j.nextInt(field_28087_j.nextInt(field_28087_j.nextInt(112) + 8) + 8);
  517. int i23 = l + field_28087_j.nextInt(16) + 8;
  518. (new WorldGenLiquids(Block.lavaMoving.blockID)).generate(field_28081_p, field_28087_j, k20, i22, i23);
  519. }*/
  520.  
  521. field_28074_w = field_28081_p.getWorldChunkManager().getTemperatures(field_28074_w, k + 8, l + 8, 16, 16);
  522. for(int i18 = k + 8; i18 < k + 8 + 16; i18++)
  523. {
  524. for(int l20 = l + 8; l20 < l + 8 + 16; l20++)
  525. {
  526. int j22 = i18 - (k + 8);
  527. int j23 = l20 - (l + 8);
  528. int k23 = field_28081_p.findTopSolidBlock(i18, l20);
  529. double d1 = field_28074_w[j22 * 16 + j23] - ((double)(k23 - 64) / 64D) * 0.29999999999999999D;
  530. if(d1 < 0.5D && k23 > 0 && k23 < 128 && field_28081_p.isAirBlock(i18, k23, l20) && field_28081_p.getBlockMaterial(i18, k23 - 1, l20).getIsSolid() && field_28081_p.getBlockMaterial(i18, k23 - 1, l20) != Material.ice)
  531. {
  532. field_28081_p.setBlockWithNotify(i18, k23, l20, Block.snow.blockID);
  533. }
  534. }
  535.  
  536. }
  537.  
  538. BlockSand.fallInstantly = false;
  539. }
  540.  
  541. public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate)
  542. {
  543. return true;
  544. }
  545.  
  546. public boolean unload100OldestChunks()
  547. {
  548. return false;
  549. }
  550.  
  551. public boolean canSave()
  552. {
  553. return true;
  554. }
  555.  
  556. public String makeString()
  557. {
  558. return "RandomLevelSource";
  559. }
  560.  
  561. private Random field_28087_j;
  562. private NoiseGeneratorOctaves field_28086_k;
  563. private NoiseGeneratorOctaves field_28085_l;
  564. private NoiseGeneratorOctaves field_28084_m;
  565. private NoiseGeneratorOctaves field_28083_n;
  566. private NoiseGeneratorOctaves field_28082_o;
  567. public NoiseGeneratorOctaves field_28096_a;
  568. public NoiseGeneratorOctaves field_28095_b;
  569. public NoiseGeneratorOctaves field_28094_c;
  570. private World field_28081_p;
  571. private double field_28080_q[];
  572. private double field_28079_r[];
  573. private double field_28078_s[];
  574. private double field_28077_t[];
  575. private MapGenBase field_28076_u;
  576. private BiomeGenBase field_28075_v[];
  577. double field_28093_d[];
  578. double field_28092_e[];
  579. double field_28091_f[];
  580. double field_28090_g[];
  581. double field_28089_h[];
  582. int field_28088_i[][];
  583. private double field_28074_w[];
  584. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!