Compare commits

...

657 Commits

Author SHA1 Message Date
E. Kim 5c8dc8f7ec
Update ko_kr.json (#1882) 2021-07-24 20:15:31 +10:00
E. Kim 94cd26a56d
Update ko_kr.json (#1879) 2021-07-08 16:52:44 +10:00
ph0elyx 0a2ad414ef
Update spanish translations (#1878)
* Update es_ar.json

* Update es_es.json

* Update es_ar.json

* Update es_es.json

* Update es_mx.json
2021-07-07 12:26:34 +10:00
KdotJPG f4a0c274ea
Improve simplex code and results, make it fully seedable. (#1874) 2021-06-30 10:31:57 +10:00
Forstride 993a556e93
Added unbreakable infertile crops tag for Serene Seasons compatibility 2021-06-21 23:05:31 -04:00
Forstride bebe90ee5e Added block/item tags for new Serene Seasons fertility system 2021-06-21 19:24:43 -04:00
Forstride 516879ed8c
Changed Woodland tree feature for Dynamic Trees compatibility 2021-06-17 07:09:57 -04:00
Adubbz c49a82b9c1 Fixed crashing when gravel beaches are disabled. Closes #1846, #1857, #1866 2021-06-17 15:06:51 +10:00
Adubbz df04ab8727 Fixed crashing with Terra. Closes #1864 2021-06-15 13:26:43 +10:00
Forstride c9cfab8065 Added missing Spanish Moss loot tables 2021-06-12 11:57:29 -04:00
Forstride 8882a9314c - Re-added the Cold Desert and Grassland biomes
- Added Tall Dead Forest, Shroomy Wetland, and Grassland Clover Patch sub-biomes
- Removed the Jade Grassland, Mushroomy Muskeg, Silkglade/Silkglade Nest, Overgrown Fungal Jungle, and Wooded Wasteland
- Reworked Redwood and Bayou tree generation (Thanks to SuperCoder79!)
- Added Spanish Moss, Clover, and Huge Clover blocks
- Tweaked the Muskeg, Seasonal Forest, Woodland, and respective sub-biomes
2021-06-07 17:30:53 -04:00
Forstride 1eeca25ed0 Added built-in classic textures resource pack (Not fully working yet), removed April Fools easter egg from the Rainbow Hills 2021-06-04 10:59:55 -04:00
Forstride 7f4c3623df Re-added the Woodland and Muskeg biomes, split the Marsh back into a primary biome
NOTE: This update will require you to clear your configs and create a new world.
2021-06-01 12:11:50 -04:00
Corail31 503cda9ef1
boat variants (#1863) 2021-05-25 08:36:09 +10:00
Aarrn33 35b5b2f340
Create fr-fr.json (#1856)
* Create fr-fr.json

* Changed file name
2021-05-15 14:03:16 -04:00
TheSonit d57bf96802
Created ukrainian localization (#1852) 2021-05-08 21:19:48 +10:00
SuperCoder79 c1615c50ef
Optimize performance and memory usage (#1850) 2021-05-06 20:49:47 +10:00
Forstride 030559a74a Merge branch 'BOP-1.16.4-13.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.16.4-13.x.x 2021-05-05 01:46:08 -04:00
Forstride d5396c0485 Fixed BOP biomes not generating flowers when using bonemeal 2021-05-05 01:45:57 -04:00
E. Kim 3a75fde67c
Update ko_kr.json (#1847) 2021-05-05 14:39:45 +10:00
Forstride 7e0b396cb6 Prevented sprouts from generating in caves 2021-05-04 18:13:14 -04:00
Forstride b393c2f109 Added trunk bushes to redwood trees 2021-05-04 03:30:56 -04:00
Forstride ba0e812ec1 Added alternate generation style for hellbark trees/saplings to make collecting wood easier 2021-05-03 20:30:00 -04:00
Forstride 3b754115a8 Changed temperatures of the Grove, Lavender Field, and Prairie so they no longer use tropical seasons in Serene Seasons 2021-05-03 19:08:43 -04:00
Forstride 22892df504 Tweaks to the Burnt Forest sub-biome 2021-04-27 16:51:58 -04:00
Adubbz 87aa9a03a9 Updated to 1.16.5 2021-04-24 10:19:47 +10:00
Adubbz 3f805e37e1 Don't upload to maven - Those who want it can use Curseforge's one instead 2021-04-24 09:59:09 +10:00
Adubbz d94e32ee3c More Jenkins changes 2021-04-24 09:54:36 +10:00
Adubbz 72d3ea9c8e More Jenkinsfile changes 2021-04-24 09:51:09 +10:00
Adubbz 8caa6a9aa2 Jenkinsfile updates 2021-04-24 09:49:27 +10:00
joker876 acd9f9db5b
pl_pl localization (#1840)
* Update pl_pl.json

* Added proper spacings here and there
2021-04-21 16:20:40 -04:00
Corgi Taco 6f3410f5cd
-Modded End and Nether chunk generator compat in BOP Worldtype (#1825) 2021-03-21 11:04:25 +11:00
ph0elyx ecec6bb865
Update spanish translations (#1821)
* Update es_es.json

* Update es_ar.json

* Update es_mx.json

* Update es_ar.json

* Update es_es.json

* Update es_mx.json
2021-03-13 19:09:01 +11:00
Forstride 624e5a29d8 Fixed beach biomes not working...For the entirety of 1.16.4... 2021-03-11 14:21:10 -05:00
zorc 6434926d54
Update zh_cn.json (#1796)
Update zh_cn.json
2021-01-26 09:41:08 +11:00
BardinTheDwarf a970db94e9
Update ru_ru.json (#1793) 2021-01-22 21:23:14 +11:00
Adubbz a276d30e1f Enqueue in common setup, closed #1758 2021-01-20 11:23:16 +11:00
Wizqok 02157af333
de_de.json uptodate (#1780)
* Update de_de.json

added all new entries, removed not used ones

* syntax
2021-01-06 09:00:51 +11:00
E. Kim a68e2a8c3d
Update ko_kr.json (#1771) 2020-12-25 22:33:33 -05:00
Forstride 967f4fa5f2 Updated some biome temperatures for Serene Seasons compatibility 2020-12-11 19:46:21 -05:00
ph0elyx 22861fdba4
Update es_es.json es_mx.json es_ar.json (#1759)
* Update es_ar.json, es_es.json, es_mx.json

* Update es_es.json, es_mx.json, es_ar.json

Co-authored-by: Felipe Clariá <63019092+feliclaria@users.noreply.github.com>
2020-12-11 09:40:09 +11:00
Adubbz cca10ac408 Adopted Forge's new world type system 2020-12-08 12:25:09 +11:00
WuzgXY 51f5cb1b6d
Correction of "Cherry" (#1749) 2020-11-28 18:46:45 +11:00
Forstride e7d0561af4 Replaced Evoker spawns in the Ominous Woods with Illusioners 2020-11-21 07:27:37 -05:00
Forstride f438861cf3 Re-added biome dictionary tags 2020-11-10 02:41:19 -05:00
Adubbz 8887217790 Scale ocean climate zooming with biome size option 2020-11-10 09:55:54 +11:00
Forstride f66a7f349e Changed foliage/leaf block loot tables to use the Forge shears tag (Closes #1689) 2020-11-09 00:47:01 -05:00
Adubbz b8bbadd73a Fixed issues with the biome config file. Closes #1693 2020-11-09 12:08:14 +11:00
Adubbz 7a9533387b Re-added support for biomes from other mods. Closes #1670 2020-11-09 11:48:33 +11:00
Felipe Clariá ae366e8877
Update es_ar.json, es_es.json, es_mx.json (#1741) 2020-11-09 11:46:06 +11:00
Forstride e93b6331f4 Changed the Volcanic Forest to a Burnt Forest sub-biome for the Dead Forest 2020-11-08 00:47:48 -05:00
Felipe Clariá 3ecc927854
Update es_ar.json, es_es.json, es_mx.json (#1737)
* Update es_ar.json, es_es.json, es_mx.json

* Fixes

* Update es_ar.json, es_es.json, es_mx.json
2020-11-06 06:58:03 -05:00
Forstride 18f2d5e66a Added Tropic Plains and Volcanic Forest sub-biomes 2020-11-06 05:14:42 -05:00
Forstride c12735accc Added ambient particles to certain biomes 2020-11-06 02:38:17 -05:00
Forstride 0123ce2257 Renamed Bamboo Grove to Bamboo Blossom Grove 2020-11-05 21:04:14 -05:00
Forstride ad1deb9352 Fixed technical biomes not being registered properly 2020-11-05 02:57:10 -05:00
Forstride 4fc61b1930 Tweaked Tundra Basin scale 2020-11-05 02:44:27 -05:00
Forstride f59bc74869 "Updated" to 1.16.4 2020-11-05 02:16:35 -05:00
Forstride 8e193fab55 Updated language files from existing PRs 2020-11-04 15:43:29 -05:00
Forstride 80d6bc0769 Finalized biome rework 2020-11-04 15:34:55 -05:00
Forstride 27c59e07eb Rework stuff 2020-10-28 05:55:07 -04:00
Forstride daffd4b951 Copied fixes over to biome rework branch 2020-10-12 06:20:26 -04:00
Forstride 69ad6bfc15 More stable than Nintendo patch notes 2020-10-07 22:06:45 -04:00
Forstride 61968d1721 Improved mahogany tree generation 2020-10-07 21:03:14 -04:00
Forstride 91c81c38f1 Even more biome rework stuff 2020-10-07 17:26:14 -04:00
Forstride 49469a9618 More biome rework progress 2020-10-07 04:40:19 -04:00
Forstride 316600aae7 More biome rework stuff 2020-10-07 00:36:04 -04:00
Forstride 692a20d335 WIP rework stuff 2020-10-06 21:37:30 -04:00
Forstride 9279cc7547 - Added Lush Desert biome
- Added Orange Sand/Sandstone (And all matching blocks for it)
- Changed the Brushland into a new biome called the Dryland
- Renamed the Origin Hills to Origin Valley
- Renamed the Rainbow Valley to Rainbow Hills
- Removed Xeric Shrubland sub-biome
- Removed Oasis sub-biome
- Improved various textures
2020-10-05 21:01:09 -04:00
SuperCoder79 1a5742af0f
Change climate offsetting to random instead of bitmask (#1690) 2020-10-05 12:11:48 +11:00
SuperCoder79 5741d6e98b
Improve Origin Hills tree generation and beach generation (#1688)
* Trees now follow Alpha Minecraft's generation gradient
* Beaches use Alpha's noise generation for sand and gravel
2020-10-04 18:14:22 -04:00
Forstride f064126e70 Removed roots (They didn't generate in 1.16.3 anyway), fixed potted sprout texture 2020-10-03 23:11:08 -04:00
Felipe Clariá a7883a194b
Update es_ar.json, es_es.json, es_mx.json (#1678)
* Update spanish

* Update es_ar.json, es_es.json, es_mx.json
2020-09-27 20:31:37 +10:00
Forstride 987a45a5c9 Re-added the Jade Cliffs. Improved the Overgrown Cliffs 2020-09-24 21:55:05 -04:00
Forstride e3467be773 Added huge toadstools to the Woodland, fixed placing seagrass on white/black sand (Closes #1668) 2020-09-24 16:10:26 -04:00
Adubbz 9af3b6f06c Also register configured origin carver 2020-09-24 14:59:54 +10:00
Adubbz 376348eb9f Moved carvers to their own class 2020-09-24 14:54:19 +10:00
Adubbz 58253db099 Whoops 2020-09-24 14:40:45 +10:00
Adubbz dfa48edd52 Removed now unnecessary workaround for configured features 2020-09-24 14:37:44 +10:00
Adubbz 70ee37f212 Fixed grass/foliage colours 2020-09-24 14:32:54 +10:00
Adubbz 39aec91eb2 wip colour stuff 2020-09-24 13:39:08 +10:00
Forstride f0663276d3 Added temporary grass color overrides for the Fungal Jungle/Rainbow Valley/Silkglade 2020-09-23 23:07:53 -04:00
Forstride 382fc4a90c Finished up feature overhaul stuff 2020-09-22 16:41:31 -04:00
Forstride 99c204f18b Yet another tedious feature overhaul commit 2020-09-22 13:34:18 -04:00
Forstride 3faab8a5dd Removed small cattails, more tedious feature stuff 2020-09-21 18:31:42 -04:00
Forstride 4ec7e4147b Even more tedious feature crap 2020-09-21 13:48:23 -04:00
Forstride 69f3c81785 More tedious feature overhauls 2020-09-21 09:28:40 -04:00
Adubbz df13f6756d Change lavender fields to use BOPConfiguredFeatures 2020-09-21 12:10:52 +10:00
Adubbz ca237aed5a More workarounds for arbitrary limitations set by Mojang 2020-09-21 11:53:34 +10:00
Adubbz 7798e91fa8 (Hopefully) fixed tree generation in all biomes 2020-09-20 11:30:14 +10:00
Adubbz 1ecc8babf3 Fixed mystic grove trees 2020-09-20 11:23:15 +10:00
Adubbz 83f0b8d4be Fixed all biomes being classed as "ocean" 2020-09-19 19:44:25 +10:00
Adubbz 7970d1bfff Hacks 2020-09-19 19:10:20 +10:00
Adubbz cc72f61a57 More feature fixes 2020-09-19 18:53:19 +10:00
Adubbz 95347887f8 Moved to 1.16.3, register surface builders 2020-09-19 17:33:59 +10:00
Adubbz 045c804f14 Compiles 2020-09-07 12:10:07 +10:00
Forstride 5441279e4c Fixed sky colors 2020-08-25 17:44:44 -04:00
Adubbz ad5259af61 Misc fixes 2020-08-25 23:06:25 +10:00
Forstride 2bc36c12ff Fixed biome classes 2020-08-25 07:51:25 -04:00
Adubbz 5dcd185f9f Updated the boreal forest 2020-08-20 20:18:53 +10:00
Adubbz dd58816617 1.16.2 setup 2020-08-20 14:04:09 +10:00
Bobcorn Octopus 7fc9ffff02
Update zh_cn.json (#1662) 2020-08-07 14:38:03 +10:00
Masterlupo c8d26102e3
Update it_it.json (#1660) 2020-08-06 17:50:36 +10:00
Forstride 4477af35d6 Fixed some biomes using water creature entity classification instead of water ambient for fish spawns 2020-07-29 19:32:40 -04:00
Felipe Clariá 9d8db7917b
Update spanish translations (#1650) 2020-07-23 14:40:54 +10:00
Forstride 0b1c6fc3a6 Added a few custom paintings 2020-07-21 15:38:37 -04:00
Adubbz 8f4a43af31 Fixed server seed inconsistency. Closes #1644 2020-07-21 13:32:11 +10:00
Smollet777 b1dd655bb5
Update ru_ru.json (#1643) 2020-07-19 17:37:54 +10:00
Forstride 4aa598b660 Added black sand/sandstone, changed the Volcano Edge biome into Volcanic Plains 2020-07-18 13:30:48 -04:00
Forstride 0a08fa9694 Merge branch 'BOP-1.16.x-11.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.16.x-11.x.x 2020-07-17 13:15:31 -04:00
Felipe Clariá 18c8392af1
Update spanish translations (#1642) 2020-07-17 13:15:11 -04:00
Forstride acde71c51c Tweaked the Bog, Grassland, and Tundra biomes 2020-07-17 13:15:09 -04:00
Forstride bcd099261b Changed the Ghost Forest to a snowy biome called the Muskeg
(Be sure to delete your existing configs and use a new world, or you will likely run into issues!)
2020-07-17 09:46:19 -04:00
Forstride 0b54837832 Improvements to the Tropics and Grassland biomes 2020-07-16 09:18:00 -04:00
Masterlupo ed4257fb70
Italian localization (#1640) 2020-07-15 13:20:49 -04:00
Adubbz 6cfa2afe4b Added an option to disable bop nether generation 2020-07-15 12:04:17 +10:00
Adubbz 99eb540906 Fixed world type resetting to Biomes O' Plenty after customizing a Vanilla worldtype 2020-07-14 20:19:02 +10:00
Felipe Clariá 9f601850fc
Update spanish translations (#1639) 2020-07-14 20:05:43 +10:00
Forstride b9fbc0d347 Added sign textures for if/when we add them 2020-07-13 17:42:18 -04:00
Forstride ccdbf253bd Merge branch 'BOP-1.16.x-11.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.16.x-11.x.x 2020-07-13 11:49:51 -04:00
Forstride fb1412909f Made the Origin Hills sand/gravel generation slightly more authentic to Alpha, removed the Origin Beach (No longer needed) 2020-07-13 11:49:24 -04:00
Adubbz bb60c8d49d Mark 1.16 builds as beta 2020-07-13 10:48:45 +10:00
Forstride fd099a00d5 Removed water/lava ponds from the Origin Hills 2020-07-12 20:39:51 -04:00
Forstride 3156168833 Merge branch 'BOP-1.16.x-11.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.16.x-11.x.x 2020-07-12 08:46:08 -04:00
Forstride 3bc5724766 Re-added Origin Grass Blocks for the Origin Hills 2020-07-12 08:45:45 -04:00
Felipe Clariá 5e16d64a0a
Update spanish translations (#1638) 2020-07-11 19:29:26 -04:00
Forstride 43f17912de Renamed Undergarden to "Undergrowth" and Shadowlands to "Withered Abyss" 2020-07-10 14:51:25 -04:00
Adubbz a0174bf1f5 Update issue template versions 2020-07-10 23:33:12 +10:00
Adubbz 0bb50a2840 Fixed GuiEventHandler causing issues on servers 2020-07-10 23:30:44 +10:00
Forstride d504aebb96 Fixed supported plant types for Dried Salt blocks 2020-07-10 07:00:53 -04:00
Adubbz ff777917a1 Forge version bump 2020-07-10 19:27:42 +10:00
Adubbz b51d9a4dce Set bop worldtype by default 2020-07-10 19:17:36 +10:00
Adubbz 94dcd5f2d7 Skip the experimental complain screen 2020-07-10 18:41:04 +10:00
Forstride 29e6569f3c Flesh tendons, new maple/autumn leaf textures 2020-07-09 16:04:29 -04:00
Adubbz 6ea9a33bc1 Fleshy tweaks 2020-07-09 22:28:57 +10:00
Adubbz dc8964a9fd More fleshy things 2020-07-09 22:18:54 +10:00
Forstride b3931fc24b Fleshy things 2020-07-08 09:29:02 -04:00
Adubbz 6a95b28bc6 The bop worldtype now works on servers again 2020-07-08 22:49:38 +10:00
Forstride 563b2857a4 Various texture/biome tweaks 2020-07-08 06:50:30 -04:00
Adubbz be402fba7f Fixed biome provider preservation across world loads 2020-07-07 22:55:36 +10:00
Forstride e33525cd99 Added recipe for Nether Crystal Blocks, tweaked cattail textures 2020-07-07 06:23:02 -04:00
Forstride ac5527fd6c More Nether biome improvements 2020-07-06 02:37:51 -04:00
Forstride 24533be7c0 More Nether biome stuff 2020-07-05 13:46:53 -04:00
Forstride 2c703ba7b3 Nether biome stuff 2020-07-05 11:57:44 -04:00
Adubbz 9281f5df44 Fixed tree decay 2020-07-05 22:59:58 +10:00
Adubbz e31d46c2af Removed /bop tpbiome as Vanilla added its own command 2020-07-05 22:40:12 +10:00
Adubbz a2b377f2d5 Nether biome placement is now not-garbage 2020-07-05 22:30:55 +10:00
Adubbz d35095a2d0 Nether biomes now work 2020-07-05 22:01:06 +10:00
Forstride 965aa0551f Added Nether Crystals, removed Ash Blocks 2020-07-05 07:34:50 -04:00
Forstride 435ee8fbb0 Textures and stuff 2020-07-05 06:19:02 -04:00
Adubbz 8651b778d2 Boats suck thank you for coming to my TED talk 2020-07-05 20:11:34 +10:00
Adubbz 4d38d284a3 Block fixes 2020-07-05 20:04:48 +10:00
Adubbz bbcfb5e948 Fixed remaining compile errors 2020-07-05 19:37:00 +10:00
Adubbz 907934184b More fixes 2020-07-05 02:08:15 +10:00
Forstride ecbeb67551 Updated wall blockstates/models, added new block/item tags 2020-07-03 13:56:32 -04:00
Forstride 6a7ce041b5 Small fixes 2020-07-03 13:13:54 -04:00
Forstride a6db9423b9 Fixed up biome classes 2020-07-03 12:47:52 -04:00
Adubbz 2a246d57bc Mappings workarounds 2020-07-04 01:20:20 +10:00
Adubbz 814c9226b1 Updated gen features (except trees) 2020-07-04 00:22:59 +10:00
Adubbz ccf63a6bc0 Misc fixes 2020-07-03 23:49:05 +10:00
Adubbz 7f721ada2f Updated mappings and bumped versions 2020-06-26 12:46:10 +10:00
peehpeh fab38c4c35
Edited spanish translations (#1621) 2020-06-01 13:45:08 +10:00
Forstride b6dd8df42d Tweaked Dune Grass and Wanderer Music Disc textures 2020-05-28 20:21:36 -04:00
Adubbz 5f8430a78d
Attempt to bump required Forge version 2020-05-21 17:49:34 +10:00
Forstride b53a98852d Added stripped wood recipes (Closes #1612) 2020-05-18 18:38:28 -04:00
AtlaStar 3321b05f22
Forge 31.2.0 fixes (#1605)
* Changed environment for testing in eclipse

* Fixes issue for Forge 31.2.0

Changes the way SoundEvents are constructed as to no longer use depreciated call to super in 31.2.0

* Remove generated files

Some things got past BiomeOPlenty's .gitignore, simply removing them before submitting a PR

* Cleanup

Should resolve style issues in PR

Co-authored-by: D Melton <55304913+DMelton1221@users.noreply.github.com>
2020-05-16 18:15:44 +10:00
Adubbz 4919a112be
Bump forge version 2020-05-15 12:32:03 +10:00
peehpeh e28ab2ca8d
Updated spanish translations (#1599) 2020-05-14 15:14:28 -04:00
Forstride b2a9ab1bad Added block.properties for shader support (Doesn't seem to be working though? OptiFine might not have re-added support yet) 2020-05-04 09:03:44 -04:00
Adubbz 30a3e3fff0
Remove this too 2020-05-01 23:52:23 +10:00
Adubbz 4b44cdc955
Remove legacy server.properties workaround 2020-05-01 23:50:57 +10:00
SuperCoder79 7bca7e9707
refactor biome layers to match vanilla's new 1.15 system (#1571) 2020-04-21 21:23:54 +10:00
LoganDark 21ae14f67b
fix infinite loop in BushTreeFeature (#1589) 2020-04-21 21:23:31 +10:00
EnterFor 3d69190338
Update zh_cn.json (#1570)
* Update zh_cn.json

Hey, I fixed the error and completed some translations,
Can you merge it? Thank you in advance!

* Update zh_cn.json
2020-03-25 21:00:41 +11:00
Adubbz 46c9ba2441
Merge pull request #1568 from TrinityDevelopers/patch-1
Correct inconsistent tabs/spaces
2020-03-22 19:07:15 +11:00
Andrew Miller ae1a2277a7
Correct inconsistent tabs/spaces 2020-03-19 11:40:52 -05:00
Adubbz ca41c32588 Fix ModFeatures indentation 2020-03-15 11:18:02 +11:00
Adubbz fc61d76d61
Merge pull request #1565 from TelepathicGrunt/BOP-1.15.x-10.x.x
Register all BoP features now into Forge's feature Registry
2020-03-15 11:13:22 +11:00
alex sarnese b7b868bc22 Register all BoP features now into Forge's feature Registry 2020-03-08 16:18:37 -04:00
Forstride b74700e5be Renamed Pink/White Cherry and Jacaranda Leaves to "Blossoms" 2020-03-07 10:14:57 -05:00
Adubbz a2538d105a
Merge pull request #1564 from Smollet777/patch-1
Update ru_ru.json (root, tall wheat)
2020-03-06 11:55:23 +11:00
Smollet777 da652d9359
Update ru_ru.json (root, tall wheat) 2020-03-05 22:03:47 +02:00
Forstride 3ab58bceb7 Re-added roots 2020-03-03 08:20:02 -05:00
Forstride b58a3ff88e Removed passive mobs from the Dead Forest, changed biome dictionary tags for the Origin Hills/Orchard 2020-02-26 09:45:33 -05:00
Forstride c1dc42290e Fixed the Snowy Taiga not generating 2020-02-22 19:04:46 -05:00
Forstride 7e0f2b8894 Added OnlyIn client annotation for GUI Event Handler (Closes #1561) 2020-02-22 14:25:04 -05:00
Adubbz e1ea75fbaa Attempt to fix bad maven universal artifact 2020-02-22 22:57:17 +11:00
Adubbz ba648379a6 Added various config options 2020-02-22 21:55:55 +11:00
Adubbz e297832f5e Make the orchard a technical biome 2020-02-22 20:32:44 +11:00
Adubbz 38522884f2 Technical biomes can now be disabled. Fixed potential crashes when disabling certain biomes 2020-02-22 20:02:17 +11:00
Adubbz b591814b1f Island biomes can now be disabled 2020-02-22 18:32:41 +11:00
Forstride 8ef12c9856 Tweaked tall wheat texture and Prairie grass/foliage color 2020-02-20 00:22:20 -05:00
Forstride e9d75a5a4f Changed barley to tall wheat and made tweaks to the Pasture biome 2020-02-19 14:45:18 -05:00
Forstride 050344333f Improved mahogany leaf texture 2020-02-19 09:01:29 -05:00
Forstride 03fa5d5034 Fixed "CliamteLayer" typo 2020-02-19 00:56:08 -05:00
Forstride 6500381007 Fixed edge biome crash, set fallback biome for empty climates to ocean 2020-02-18 08:46:31 -05:00
Forstride 12277ce96f Tweaks to the Bog, Mangrove, and Tundra 2020-02-18 08:29:02 -05:00
Forstride 16d0e0f7a7 Removed Glowstone Grotto nether biome (NOTE: CONFIGS NEED TO BE DELETED OR YOUR GAME WILL CRASH ON LOAD!) 2020-02-18 07:21:12 -05:00
Adubbz 42680921e5 Vanilla biome weights are now configurable 2020-02-18 22:58:12 +11:00
Forstride efca80836c Added more tall grass to the Lush Grassland, made the Floodplains flatter 2020-02-18 01:43:56 -05:00
Forstride 10d94df8d7 Changed the Rainforest back to a subtropical biome
NOTE: This will affect existing worlds and cause chunk borders!  Additionally, please delete old configs before creating a new world!
2020-02-17 08:22:03 -05:00
Adubbz fa6dd5f3be Fixed structure generation. Closes #1531 2020-02-16 20:48:02 +11:00
Smollet777 974a1cc242
Update ru_ru.json (#1548)
dried salt
dead branch
2020-02-16 01:40:36 -05:00
E. Kim dea75e0f74
Update ko_kr.json (#1553)
* Update ko_kr.json

* Update ko_kr.json
2020-02-16 01:40:29 -05:00
Forstride e612de9359 Reduced the amount of brown mushrooms in the Mire. Removed ponds from the Prairie 2020-02-14 01:51:25 -05:00
Forstride da86c23c27 - Added Snow Golem spawns to the Alps
- Added Evoker spawns to the Ominous Woods
- Added Stray spawns to the Wasteland
- Removed witch huts from the Bog, Ghost Forest, and Marsh
2020-02-14 00:17:41 -05:00
Adubbz 15078fde5a Sort biome weights json alphabetically 2020-02-14 13:18:48 +11:00
Adubbz 8fbe69e163 Simplified standard biome weights config 2020-02-14 11:02:25 +11:00
Smollet777 f2222e3958
Update ru_ru.json (Fungal Jungle) (#1546) 2020-02-13 13:05:19 -05:00
Forstride 9190077145 Removed bee nests from the Prairie and Tropical Rainforest 2020-02-13 03:51:38 -05:00
Forstride ac218d5153 Allowed TNT to be crafted with white sand, and rabbit stew to be crafted with toadstools. Updated block/item tags 2020-02-13 01:36:40 -05:00
Forstride 2f99887eb7 Updated biome dictionary tags 2020-02-13 00:38:26 -05:00
Forstride c7ff6cc032 - Added Fungal Jungle overworld biome
- Added Huge Glowshrooms and Huge Toadstools
- Removed Fungi Forest Nether biome
- Re-added hostile mobs to the Tropics/White Beach biomes
- Cleaned up vanilla biome climate registration
2020-02-12 08:35:14 -05:00
Adubbz aa943081e3 Prefix modid in weights config for standard biomes, fallback on Ocean for empty climates 2020-02-11 21:04:36 +11:00
Adubbz 9a8f7727b4 Preliminary biome weight config file implementation 2020-02-11 19:32:56 +11:00
Adubbz 656399c37d Refactored biome registration 2020-02-11 18:13:08 +11:00
E. Kim 5006dc4d99
Create ko_kr.json (#1545) 2020-02-11 01:13:03 -05:00
Forstride e884a076cc Fixed the Wooded Badlands Plateau not generating 2020-02-10 00:37:25 -05:00
Forstride 3f59e898a8 Adjusted lush swamp/rainforest temperatures to be in line with other tropical biomes 2020-02-09 20:01:59 -05:00
Forstride b9aa7d96ca Tweaked the grass color of the Origin Hills 2020-02-09 06:39:35 -05:00
Forstride a18aeee5c7 Added branches for dead trees 2020-02-09 01:20:12 -05:00
Forstride 6f0d4fd3da Renamed Dried Sand to Dried Salt, tweaks to the Wasteland biome 2020-02-08 08:53:41 -05:00
Forstride d834a5c637 Improvements to the Ghost Forest and Mire 2020-02-07 00:23:14 -05:00
Forstride 7b0edb129e Added better edge casing for swamp <-> jungle biomes, minor biome tweaks 2020-02-06 23:00:06 -05:00
Forstride 165a8d5e63 Changed Origin Leaves/Sapling texture, minor biome tweaks 2020-02-06 21:22:32 -05:00
Forstride cf2fa10d2b Merge branch 'BOP-1.15.x-10.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.15.x-10.x.x 2020-02-06 08:13:31 -05:00
Forstride fb6f02dcb6 Updated door/trapdoor textures 2020-02-06 08:13:11 -05:00
Adubbz 4fff57deff
Merge pull request #1541 from Smollet777/patch-2
Update ru_ru.json (Ghost forest)
2020-02-06 19:46:18 +11:00
Smollet777 e45533ba5b
Update ru_ru.json (Ghost forest) 2020-02-06 10:45:35 +02:00
Forstride 4c4d3f7a8b Added Ghost Forest biome, moved Rainforest biome from Subtropical to Tropical climate, improvements to Mire biome 2020-02-06 00:44:14 -05:00
Adubbz f0b00091e7
Merge pull request #1540 from HJ-zhtw/HJ-zhtw-patch-1
Update zh_tw.json
2020-02-03 23:05:23 +11:00
__HJ f8f9b3de46
Update zh_tw.json
- Translated Sprout & Toadstool
2020-02-03 19:58:29 +08:00
__HJ d6a1e3aeca
Create zh_tw.json (#1539)
Here comes the translations of Traditional Chinese. Based on the Simplified, but I really reedited it "from head to toe."
It took me so much time to finish removing texts and resorting.

Highlights:
- Localized for Traditional Chinese
- Updated all of the strings, e.g. Removing the things that no longer exist, Adding the new things released, Resorting the strings according to en_us.

PS, The strings of Biome is untranlated for now as I'm exhausted and I have no idea where it would show. Anyway, those who want to translate it completely don't need to worry about that, like aforementioned, I've resorted all of the strings, just go translating!

Any sugesstion/correction would be appreciated.
2020-02-02 22:10:11 -05:00
Forstride 9d12744124 Removed lava lakes from the Poppy Field 2020-01-27 16:57:54 -05:00
Adubbz 1784846496
Merge pull request #1536 from HeresHavi/BOP-1.15.x-10.x.x
Added Poppy Fields nl translation
2020-01-25 12:30:43 +11:00
Rico ea68465148
Added Poppy Field biome 2020-01-25 02:14:32 +01:00
Adubbz 301eed4282 Updated to Minecraft 1.15.2 2020-01-25 00:40:20 +11:00
Smollet777 acd0a41d1e update ru_ru.json (poppy field) (#1534) 2020-01-23 08:39:05 -05:00
Forstride 6ea189b002 Tweaks to Poppy Field rarity/mob spawns 2020-01-23 07:00:37 -05:00
Forstride 0c87454b31 Added Poppy Field biome 2020-01-23 05:55:23 -05:00
Adubbz 1421f9ef8b Do biome dictionary and villager type registration earlier. Closes #1529 2020-01-19 10:42:23 +11:00
Forstride d116ef13ee Tweaks to the Mystic Grove 2020-01-06 14:35:51 -05:00
Smollet777 b64be5a89a Update ru_ru.json (#1527) 2020-01-07 01:11:42 +11:00
Rico 49e6528ee5 Dutch Localization (#1525) 2020-01-03 15:35:24 +11:00
Forstride eada57a419 Added villager types for remaining biomes 2020-01-02 03:08:07 -05:00
Forstride df98950041 Minor biome tweaks 2020-01-01 20:07:52 -05:00
Adubbz 9a35bb4915 Fixed villager types. Closes #1519 2020-01-01 19:46:05 +11:00
Adubbz ad525e7987 Fixed nether fortress generation. Closes #1523 2020-01-01 19:22:19 +11:00
Adubbz f9d4959bc8 Fix huge mushroom generation in BOP biomes. Note that this is still broken in Vanilla biomes due to a Forge bug. The Forge bug is present with or without BOP installed. 2020-01-01 17:15:49 +11:00
Adubbz 01eabf4aab Fixed recursion crash in some generation features 2020-01-01 09:55:36 +11:00
Adubbz 883717a7c1 Mappings overhaul 2019-12-31 18:31:48 +11:00
Forstride b89bf2e58b Gave Rainbow Leaf coloration a wavy pattern 2019-12-30 12:39:27 -05:00
Forstride 79ff303edc Added bees to the Rainbow Valley 2019-12-30 03:06:01 -05:00
Forstride fbc3c11a07 Added Rainbow Birch trees and Rainbow Valley island biome 2019-12-29 23:20:12 -05:00
Forstride 6fbf2bc527 Replaced the Jacaranda leaves in the Highland Moor with Violets 2019-12-29 20:47:30 -05:00
Forstride bf9ac947e4 Fixed big oak trees not generating 2019-12-28 23:44:31 -05:00
Adubbz ce2a82d860 Updated issue templates for 1.15 2019-12-28 21:12:54 +11:00
Smollet777 1e519393f1 Update ru_ru.json (#1520)
Removed End biome stuff
2019-12-28 21:09:24 +11:00
Adubbz 80e1d30c29 Fixed boats. Closes #1518 2019-12-28 12:38:34 +11:00
Adubbz 93aa27cd66 Water plants still suck 2019-12-28 12:05:07 +11:00
Adubbz a3c211c953 Fix water plants 2: Electric boogaloo. Closes #1516 2019-12-28 10:50:53 +11:00
Adubbz 62c3a88b65 Mark doors and trapdoors as noOcclusion. Closes #1517 2019-12-28 09:48:12 +11:00
Forstride 3ae21f3370 Removed squid spawns from normal biomes 2019-12-27 10:43:20 -05:00
Forstride 5d602bcc6b Added bees to various biomes 2019-12-27 09:10:22 -05:00
Adubbz 6abee962d5 Fixed water plant generation 2019-12-27 18:39:58 +11:00
Adubbz e209b53009 Fixed trees growing from saplings 2019-12-27 17:55:04 +11:00
Adubbz fda42522f1 Fixed tpbiome comman 2019-12-27 09:27:35 +11:00
Forstride 979b540b8b Lowered lilypad spawn frequency 2019-12-26 12:56:30 -05:00
Adubbz 72badaaeff Fixed overworld biomes generating in the nether 2019-12-26 20:58:50 +11:00
Adubbz 29941fa176 Change biomes to use Mojang's builder model 2019-12-26 20:47:18 +11:00
Adubbz 1fb942549c Update curse gradle 2019-12-26 19:53:01 +11:00
Adubbz 25225a82e7 Fixed leaves occlusion 2019-12-26 19:50:59 +11:00
Adubbz f441328158 Mappings updates 2019-12-26 19:39:05 +11:00
Forstride 7b727bfbcf Fixed block rendering types 2019-12-26 02:14:28 -05:00
Adubbz cd43eceda6 Version bump 2019-12-26 17:43:41 +11:00
Adubbz b0d6aaa504 Runs 2019-12-26 17:42:37 +11:00
Forstride cf8c7233d4 Oops 2019-12-26 00:51:05 -05:00
Adubbz b6513a05b1 Now compiles 2019-12-26 16:34:54 +11:00
Adubbz c509ad4f73 Finished updating biomes 2019-12-26 15:58:02 +11:00
Adubbz 7d8f604f71 Fixed gen layers 2019-12-26 15:08:26 +11:00
Forstride e7fa9f2959 Tree stuff 2019-12-25 22:31:52 -05:00
Adubbz fe14627fc1 Merge branch 'BOP-1.15.x-10.x.x' of github.com:Glitchfiend/BiomesOPlenty into BOP-1.15.x-10.x.x
# Conflicts:
#	src/main/java/biomesoplenty/common/block/trees/EtherealTree.java
#	src/main/java/biomesoplenty/common/world/gen/feature/BOPBiomeFeatures.java
2019-12-26 13:48:41 +11:00
Adubbz 36189b68e3 More tree stuff 2019-12-26 13:43:42 +11:00
Forstride e99690d60f Removed End biome stuff 2019-12-25 18:44:22 -05:00
Adubbz d6ae490f4b Fixes 2019-12-26 10:14:01 +11:00
Adubbz 5bd54e57d3 Mass fixes 2019-12-25 19:38:59 +11:00
Adubbz 877aa321ac More mappings 2019-12-25 09:24:33 +11:00
Adubbz 1d2a4a57c6 Many fixes 2019-12-25 00:54:37 +11:00
Adubbz ef64a3a2cc Various mappings, some initial fixes 2019-12-24 22:25:03 +11:00
Adubbz a8a695afc1 Setup support for custom mappings 2019-12-24 21:08:51 +11:00
Adubbz ea9e47b29d Updated for latest MCP mappings 2019-12-21 22:58:29 +11:00
Adubbz 985d240bbe Fixed compile error 2019-12-14 21:44:32 +11:00
thedarkcolour 1a37569034 Optimized tpbiome command by using ExecutorService (#1504) 2019-12-14 18:40:58 +11:00
Forstride 7c4f41c6db
Merge pull request #1498 from BlackNightDragon/BlackNightDragon-patch-2
Update ru_ru.json
2019-12-02 07:22:10 -05:00
BlackNightDragon 7725f26752
Update ru_ru.json
Added a missing strings and fix other cosmetic things.
2019-11-24 03:22:14 +07:00
BlackNightDragon 0c360e4dc5
Update ru_ru.json
Added a missing strings and fix other cosmetic things.
2019-11-24 03:16:53 +07:00
Adubbz 1ad433a6b4
Merge pull request #1495 from BlackNightDragon/BlackNightDragon-patch-2
New russian translation
2019-11-22 10:55:44 +11:00
BlackNightDragon 55c0743967
Create ru_ru.json 2019-11-19 22:56:56 +07:00
Adubbz ebbb29db19
Merge pull request #1490 from El-Limbo/patch-3
Massive Spanish Translation (AR)
2019-11-10 19:20:25 +11:00
Adubbz 13ce1c5193
Merge pull request #1491 from El-Limbo/patch-4
Massive Spanish Translation (MX)
2019-11-10 19:20:18 +11:00
Adubbz 6248e6a7c2
Merge pull request #1489 from El-Limbo/patch-2
Massive Spanish Translation (Spain)
2019-11-10 19:20:08 +11:00
El-Limbo a8bbdd108b
Create es_mx.json
And the méxico spanish lang file
2019-11-08 22:52:34 -03:00
El-Limbo aad0108663
Create es_ar.json
Argentina Spanish Lang File
2019-11-08 22:50:00 -03:00
El-Limbo c222e051c0
es_es Lang File
Europe Spanish Lang File
2019-11-08 22:09:20 -03:00
Forstride ea6b3ed4f8
Updated Discord link in README.md 2019-10-22 13:40:23 -04:00
Adubbz 998efb6aa5 Update to Forge RB, update MCP mappings 2019-10-04 19:46:14 +10:00
Adubbz 99648cb276
Merge pull request #1466 from Ilos/patch-2
update german translation to match vanilla names
2019-09-15 20:21:38 +10:00
Forstride ba79043436 Fixed mangrove root/reed/watergrass loot tables 2019-09-06 17:36:26 -04:00
Forstride 7b584af533 Changed reeds, watergrass, and mangrove roots into proper double tall blocks. NOTE: This will cause issues in existing worlds! Update at your own risk! 2019-09-01 15:15:09 -04:00
Ilos 7e9cdf12c5
update german translation to match vanilla names 2019-08-30 18:15:17 +02:00
Forstride 8cfe54f4f9 Removed witch huts from the Mangrove and Highland Moor 2019-08-30 07:42:44 -04:00
Forstride 33d17288e1
Merge pull request #1465 from Ilos/patch-1
Create de_de.json
2019-08-29 21:32:38 -04:00
Ilos 273953e6e5
Create de_de.json
add german translation
2019-08-30 03:16:45 +02:00
Forstride fed9774a46 Optimized class imports 2019-08-28 07:30:51 -04:00
Forstride 7ea2605756 Changed blue hydrangeas and goldenrods into tall flowers (NOTE: This may cause issues in existing worlds! Update at your own risk!) 2019-08-27 14:06:48 -04:00
Forstride 7c82ce7a42 Made poplar tree generation look slightly more natural 2019-08-25 05:16:15 -04:00
Forstride aaa1b7c337 Fixed big trees not generating alternate leaves 2019-08-24 08:11:36 -04:00
Forstride da78fdd52d Added a deeper middle block layer for the Alps and Volcano biomes, fixed big trees not growing on non-soil blocks, fixed ash/mud/flesh blocks not having proper shading (At the expense of not sinking into the blocks) 2019-08-24 06:49:25 -04:00
Forstride 48aa602981 Prevented non-opped players from using the tpbiome command (Closes #1459) 2019-08-24 04:28:08 -04:00
Forstride ed7b19ba9e Changed texture folder names to match vanilla (NOTE: This will break existing texture packs with BOP support!) 2019-08-23 18:33:47 -04:00
Forstride 48082e8a54 Fixed sparse trees not being sparse, and huge trees in the Mystic Grove being too huge 2019-08-23 13:17:13 -04:00
Adubbz a8ef891b37 General system stability improvements to enhance the user's experience. Closes #1439 2019-08-23 22:09:07 +10:00
Adubbz fa5fbc23c8 Fixed rare biome generation. Closes #1438 2019-08-23 21:02:37 +10:00
Forstride 4fc7f77f34 Fixed trees not growing around ground foliage (Closes #1461) 2019-08-23 02:23:48 -04:00
Forstride 5b025fb267 Added missing smooth white sandstone recipe 2019-08-23 01:30:10 -04:00
Forstride b9dcbf6d08 Updated Forge to 28.0.55, improved mod logo 2019-08-21 09:21:24 -04:00
Forstride 84e8e21297 Added Jacaranda trees to the vanilla Flower Forest, added big Jacaranda tree variant to Lavender Field/sapling 2019-08-21 05:06:29 -04:00
Forstride 0703f0f63d Changed order that blocks are registered for cleaner creative menu 2019-08-20 05:57:02 -04:00
Forstride 37b8e6615e Fixed Ethereal wood map colors 2019-08-20 01:52:35 -04:00
Forstride f72b585e2a Tweaked various biome weights (WARNING: This update will cause abrupt chunk borders in existing worlds! Update at your own risk!) 2019-08-13 03:34:44 -04:00
Forstride f322a68c92 Removed Lily of the Valley from the Prairie 2019-08-13 00:13:07 -04:00
Forstride 7c3340de32 Lowered the amount of trees in the Snowy Coniferous Forest/Snowy Forest, tweaked how Orchards generate within Plains to better match vanilla 2019-08-12 22:32:29 -04:00
Forstride 92c5d14a74 Added Fir/Snowy Fir Clearing and Temperate Rainforest Hills sub-biomes, renamed Moor to Highland Moor, made a separate climate for the Wasteland, allowed Deep Warm Ocean to generate within Warm Oceans (NOTE: This update will cause abrupt chunk borders in existing worlds! Update at your own risk!) 2019-08-11 11:02:56 -04:00
Forstride 5f238f2031 Use white sand instead of normal sand for sediment in the Mystic Grove 2019-08-11 05:15:53 -04:00
Forstride c3be92173c Tweaked cypress tree generation 2019-08-11 05:04:57 -04:00
Forstride 4552aa716d Added large versions of the yellow/orange autumn and maple trees 2019-08-11 02:43:19 -04:00
Forstride 378266175a Lush Swamp should be in Subtropical climate, not Wet Temperate. Adjusted Mangrove and Bayou weights (NOTE: This update will cause abrupt chunk borders in existing worlds! Update at your own risk!) 2019-08-10 23:47:38 -04:00
Forstride f5309bae51 Removed Dry Plains biome, moved Lush Swamp back to the Wet Temperate climate, renamed Glowstone Cavern to Glowstone Grotto (NOTE: This update will cause abrupt chunk borders in existing worlds! Update at your own risk!) 2019-08-10 23:31:08 -04:00
Forstride 552e3511aa Updated BOP icon, fixed Origin Hills underwater fog color 2019-08-10 22:16:31 -04:00
Forstride f8ce3f8055 Improved poplar tree generation 2019-08-10 08:19:22 -04:00
Forstride 1c6b1f66c4 Changed default Wet Temperate climate temperature to Cool 2019-08-10 06:21:25 -04:00
Adubbz 18946ec9ec Don't convert biomes already registered to a climate via our api 2019-08-10 20:15:51 +10:00
Adubbz 786d0416c3 Fixed mod version. Closes #1422 2019-08-10 19:42:27 +10:00
Adubbz 76e1664844 Copy modded biomes to our worldtype. Closes #1428 2019-08-10 19:16:51 +10:00
Forstride a4e70ccc71
Merge pull request #1448 from Corail31/BOP-1.14.x-9.x.x
fix #1446 & add dispenser behavior for bop boats
2019-08-10 04:27:55 -04:00
Corail31 da98209404 fix #1446 & add dispenser behavior for bop boats 2019-08-10 10:11:24 +02:00
Forstride cebf4dea75 Improved Cherry Log textures 2019-08-10 04:11:07 -04:00
Adubbz 0e19ff4312 Merge branch 'BOP-1.14.x-9.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-08-10 16:17:03 +10:00
Adubbz 073cd6fbb3 Put config loading back in construction. Closes #1447 2019-08-10 16:16:39 +10:00
Forstride 66d0c6e5c5 Improved the Bayou biome, allowed all BOP biomes to be spawned in 2019-08-10 01:29:48 -04:00
Adubbz d664cd9e1e Perform registration during the registration events. Closes #1444 2019-08-10 13:35:50 +10:00
Adubbz f51511b738 Updated to Forge 28.0.45... It works fine? 2019-08-10 12:51:40 +10:00
Forstride 6397ced587 Merge branch 'BOP-1.14.x-9.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-08-06 16:32:47 -04:00
Forstride f9d74389c1 Fixed a potential crash caused by big oak trees, tweaked a few textures 2019-08-06 16:32:22 -04:00
Forstride ada8e9df61
Merge pull request #1437 from Waterrail/patch-1
Update pl_pl.json
2019-08-06 11:40:34 -04:00
Waterrail eef914cbdc
Update pl_pl.json
Poprawiono niektóre nazwy, by były bardziej spójne z vanilla Minecraft
2019-08-06 17:37:18 +02:00
Forstride 4f1a1276e4 Various biome tweaks 2019-08-06 11:14:28 -04:00
Forstride fd082d19c1 Tweaked mud generation in Mangroves 2019-08-05 23:50:06 -04:00
Forstride 3450b516c1 Changed beach biomes for vanilla biomes, added the Mangrove as a beach biome for tropical biomes, moved the Lush Swamp to the Warm Temperate climate (NOTE: This can cause abrupt chunk borders in existing worlds! Update at your own risk!) 2019-08-05 23:31:54 -04:00
Forstride 09040388a0 Added BOP features to various vanilla biomes (NOTE: This will also affect the Default world type. Load existing vanilla worlds at your own risk!) 2019-08-05 19:56:06 -04:00
Forstride 9d79c9a2af Allowed Sprouts to be placed in Flower Pots, made Toadstools more common 2019-08-05 05:10:42 -04:00
Forstride 7688e3ff82 Work on End biomes 2019-08-05 01:37:45 -04:00
Forstride f334573f3c Removed Poison Puffs 2019-08-04 23:51:11 -04:00
Forstride 859d9dd05d "Fixed" Flowering Oak leaf model in Fast graphics 2019-08-04 23:34:08 -04:00
Forstride dffbbc8f1b Finished up Nether biomes, which now generate 2019-08-04 08:53:48 -04:00
Adubbz d7e36a8ac0 Added support for Nether biomes 2019-08-04 22:04:37 +10:00
Forstride 689c3d5f00 More work on Nether biomes 2019-08-04 04:38:59 -04:00
Forstride ec0977da4d More work on Nether biomes, tweaks to the Tundra and Bog biomes 2019-08-04 00:26:18 -04:00
Forstride f303021c7b Changed Nether Sprouts into regular Sprouts and allowed them to grow on any block with a solid top 2019-08-03 02:45:56 -04:00
Forstride 2615f757fc Started working on Nether biomes/End biomes (Currently not available), fixed Polish localization file name (Closes #1432) 2019-07-31 20:08:21 -04:00
Forstride 4de28da3b0
Merge pull request #1427 from Corail31/BOP-1.14.x-9.x.x
bop boats now extends BoatEntity
2019-07-29 21:10:38 -04:00
Corail31 ce1cdff408 bop boats now extends BoatEntity 2019-07-30 02:17:25 +02:00
Forstride 5193e0e67c
Merge pull request #1426 from Corail31/BOP-1.14.x-9.x.x
fix boat inputs allowing to move
2019-07-29 14:07:52 -04:00
Corail31 c341b1d687 adapt without event 2019-07-29 14:04:20 +02:00
Corail31 d7412bb750 fix boat inputs allowing to move
and also removes the import in the api
2019-07-29 12:48:34 +02:00
Adubbz 8c4c64d559
Merge pull request #1425 from Corail31/BOP-1.14.x-9.x.x
fix custom boats
2019-07-29 18:15:30 +10:00
Corail31 184761785c fix custom boats 2019-07-29 10:12:20 +02:00
Forstride c6e1abbe14 Fixed Flowering Oak Sapling loot table (Closes #1424) 2019-07-29 02:08:29 -04:00
Forstride 0fe5beb957 Improved reed/cattail texture 2019-07-29 01:36:00 -04:00
Forstride 5f09ca000d Fixed flammability for foliage/wood blocks and removed unnecessary classes 2019-07-29 00:10:48 -04:00
Forstride 1d467724df Added Polish translation (Made by DarkKnightComes) 2019-07-28 22:08:43 -04:00
Forstride 02404340cc Fixed plant sustainability for white sand/mud, fixed cattails being able to grow on top of each other 2019-07-28 06:38:55 -04:00
Forstride 19c5032dc4 Added foxes to our biomes because I somehow forgot to 2019-07-28 05:11:16 -04:00
Forstride 3a4458a666 Started working on re-adding boats (Still broken, boat items spawn oak boats for the time being) 2019-07-27 21:14:29 -04:00
Forstride 7a560a8fd9 Allowed BOP saplings/flower/mushrooms to be placed in flower pots, added suspicious stew effects for BOP flowers, added makeshift vanilla sign recipes using BOP planks 2019-07-27 06:39:31 -04:00
Forstride 5ea3b0996e Allowed BOP logs to be stripped (Closes #1394), and saplings/leaves/plants to be composted 2019-07-27 01:12:22 -04:00
Forstride 4e33f53f8a Fixed sounds/tool effectiveness for various blocks, renamed block/item classes to match 1.14 naming convention 2019-07-26 06:57:24 -04:00
Forstride b9eb540c98 For some reason the last commit didn't fully work? 2019-07-25 18:38:52 -04:00
Forstride 3efcf8059f Removed tiny cacti and mud ball entity, fixed stack sizes for mud balls/music disc 2019-07-25 18:37:45 -04:00
Adubbz 89783dc592
Merge pull request #1420 from Solid-Block/patch-1
Update zh_cn.json
2019-07-24 17:03:19 +10:00
SolidBlock a3e8f1f37b
Update zh_cn.json
fixed mistakes 修复错误
2019-07-24 14:14:13 +08:00
Forstride 0c47a3dac0 Merge branch 'BOP-1.14.x-9.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-07-24 01:59:08 -04:00
Forstride 57d24ab3a6 Fixed reed/watergrass/mangrove root item placement (Again...), removed sweet berry bushes from Orchards 2019-07-24 01:58:38 -04:00
Adubbz b6f15e77d3 Update Forge and MCP mappings 2019-07-23 11:44:08 +10:00
Forstride 6f9d9ffd56 Added bamboo to Cherry Blossom Grove and Tropics 2019-07-22 02:40:59 -04:00
Forstride 20778d8633 Fixed advancements, temporarily removed boat/sign files 2019-07-21 23:33:50 -04:00
Adubbz 89cc842ba0 Updated to 1.14.4 2019-07-22 10:42:00 +10:00
Adubbz 5593a6dd75
Merge pull request #1418 from dmitrij-drandarov/BOP-1.14.x-9.x.x
Update to latest mappings (20190721) and forge version (1.14.3)
2019-07-21 22:18:05 +10:00
Dmitrij Drandarov 94f768b689 Update to latest mappings (20190721) and forge version (1.14.3) 2019-07-21 14:14:25 +02:00
Adubbz 1b38a12465 Bump Forge version 2019-07-04 19:03:13 +10:00
Forstride e3d20e621b
Merge pull request #1408 from XuyuEre/patch-6
Update zh_cn.json
2019-07-02 16:54:35 -04:00
xuyu0v0 a0f2a6fd95
Update zh_cn.json
Add new Translation.
2019-07-02 16:52:58 -04:00
Adubbz ebd9b2c102 Workaround server.properties being overwritten by introducing a config option for using the BoP worldtype on servers 2019-07-02 01:13:43 +10:00
Forstride 1e1a23b5cd Allowed fir, redwood, and umbran saplings to grow 2x2 trees 2019-06-28 16:16:40 -04:00
Forstride 0b8f81b801 Merge branch 'BOP-1.14.x-9.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-06-28 09:40:41 -04:00
Forstride 50b8ac79ca Added villages to BOP biomes 2019-06-28 09:38:31 -04:00
Adubbz 93f4005907 Fix issue template ordering 2019-06-28 13:53:11 +10:00
Adubbz c0aa1d6709 Updated issue templates 2019-06-28 13:51:52 +10:00
Forstride 648723ea6b Updated a few additional textures 2019-06-27 22:42:49 -04:00
Forstride 1af555f8b2 Updated Ethereal wood textures 2019-06-27 21:30:38 -04:00
Adubbz 36b2a2170e Added support for the bamboo forest 2019-06-28 11:12:07 +10:00
Forstride 51b1d5dfb1 Switched to DefaultBiomeFeatures for common vanilla features in biomes 2019-06-27 16:52:52 -04:00
Forstride f3be863e22 Added block drop loot tables 2019-06-26 07:23:43 -04:00
Forstride 12e55d9983 Added mud brick/white sandstone walls, cut/smooth sandstone slabs, and smooth sandstone stairs 2019-06-25 19:57:27 -04:00
Forstride 7d459d7cb9 Fixed fence data tags, renamed music disc stuff to match vanilla 2019-06-25 19:02:54 -04:00
Forstride 8d9cbadd83 Added sweet berry bushes to our biomes 2019-06-25 12:11:02 -04:00
Forstride bab7465770 Added new vanilla flowers to our biomes, added JSON files for new white sandstone/mud brick stuff 2019-06-25 08:24:21 -04:00
Adubbz 3bc801338a Updated to 1.14.3 2019-06-25 18:58:34 +10:00
Adubbz 9fdd228178 All current compile errors fixed 2019-06-25 18:33:02 +10:00
Adubbz 47ba320312 Updated commands. Only trees remain 2019-06-25 17:56:34 +10:00
Adubbz c54f209808 Various fixes 2019-06-25 17:20:36 +10:00
Adubbz 14a709ee00 Finished updating biomes 2019-06-25 16:47:04 +10:00
Adubbz 28bf6c0bec Many biome fixes 2019-06-25 15:33:43 +10:00
Adubbz 0f435c7f93 Finished off worldgen (except trees) 2019-06-25 13:48:39 +10:00
Adubbz e98567ca4f Merge branch 'BOP-1.14.x-9.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-06-16 18:21:59 +10:00
Adubbz c75ac189b0 Update mcp mappings 2019-06-16 18:21:36 +10:00
Forstride 4b8069139c Added texture update textures as the defaults 2019-06-14 01:20:02 -04:00
Adubbz 567b505439 Fixes 2019-06-14 00:00:59 +10:00
Adubbz 5b42883511 GenLayers updated, misc other stuff 2019-06-13 21:30:50 +10:00
Adubbz 9ffb7c5e5f Merge branch 'BOP-1.13-8.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-06-13 17:37:18 +10:00
Adubbz cde4ad9871 Biome updates 2: Electric Boogaloo 2019-06-13 17:31:07 +10:00
Adubbz be037ab704 First pass of biome updates 2019-06-13 16:07:49 +10:00
Adubbz 23d673cbb0 Updated blocks 2019-06-13 15:08:11 +10:00
Forstride 23ad4b22dd Changed Cold Desert to not have snow, added missing override annotations 2019-06-13 00:49:50 -04:00
Adubbz eb7114b90e Merge branch 'BOP-1.13-8.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.14.x-9.x.x 2019-06-13 12:58:48 +10:00
Forstride 82f4c5adf6 Various biome tweaks 2019-06-11 02:23:23 -04:00
Forstride 25025fa0ff Tweaked flower generation for certain biomes 2019-06-09 11:00:30 -04:00
Forstride 3a8abc08f0 Added Lush Grassland biome 2019-06-09 05:20:31 -04:00
Forstride b8ea059b65 Changed dead tree generation, increased cattail amounts in biomes that have them 2019-06-08 05:44:16 -04:00
Forstride dbfe3a5c74 Fixed placement check for giant trees in the Mystic Grove 2019-06-08 00:57:14 -04:00
Adubbz 9fa38b93a5 Fork off for 1.14 2019-06-08 13:59:20 +10:00
Forstride 55f9e9a1ee Various biome tweaks 2019-06-07 01:20:52 -04:00
Forstride 5fe2002a55 Started experimenting with End biomes (Not currently available yet) 2019-06-05 23:04:26 -04:00
Forstride 6935d814eb Fixed a crash caused by bramble blocks, various biome tweaks 2019-06-05 04:23:07 -04:00
Forstride ee7eb08ce3 Various biome tweaks 2019-06-04 21:31:59 -04:00
Forstride cd844584af Prevented non-overworld dimensions from using BOP's overworld biome provider 2019-06-04 20:35:54 -04:00
Forstride 56d4fee422 Various biome tweaks 2019-06-04 13:36:28 -04:00
Forstride cf568cc2ab Various biome tweaks 2019-06-04 10:26:27 -04:00
Forstride 3881e7731a Various biome tweaks 2019-06-04 00:02:18 -04:00
Forstride be568c0612 Fixed the bases of fir/redwood trees not generating properly. Various biome tweaks 2019-06-03 20:24:08 -04:00
Forstride 4370284949 Renamed the Dead Swamp to Mire, renamed the Highland Moor to Moor, various biome tweaks 2019-06-03 08:06:04 -04:00
Forstride 545f4bfb6c Changed the Orchard biome to a sub-biome of the vanilla Plains (Replacing the Forest as its sub-biome), improved the Grove biome, prevented Plains/Forest islands from generating within oceans, added the vanilla Desert as an edge biome of the Wasteland 2019-06-02 20:19:23 -04:00
Forstride 15692a62ce Cleaned up unused class imports 2019-06-02 05:03:53 -04:00
Forstride 8609474464 Updated issue templates 2019-06-01 14:29:26 -04:00
Forstride fc5ced7b8e
Update question.md 2019-06-01 14:21:17 -04:00
Forstride 744e7533a1
Update question.md 2019-06-01 14:19:41 -04:00
Forstride fa07ef85d6
Update question.md 2019-06-01 14:19:20 -04:00
Adubbz e0b2228052 Fixed server crashing on boot. Closes #1401 2019-06-01 18:12:11 +10:00
Forstride 6e3d1abf0e Various biome tweaks 2019-05-31 16:38:15 -04:00
Forstride cf097bf273 Tweaks to the Bog biome 2019-05-31 08:08:32 -04:00
Forstride 15a9d26d97 Removed the Bog Mire sub-biome, renamed the Bog biome to Dead Swamp, added a new Bog biome based on a cranberry bog 2019-05-31 01:46:51 -04:00
Forstride 6be2d7d8b8 Added natural carved pumpkins/jack-o-lanterns to the Pumpkin Patch biome. Removed unused textures 2019-05-30 16:58:36 -04:00
Forstride 07e23ec0ff Added Pumpkin Patch sub-biome to the Seasonal Forest 2019-05-29 20:56:49 -04:00
Forstride a28abaa24b Biome tweaks 2019-05-27 19:55:15 -04:00
Forstride 8408bf093e Fixed some improper biome tags 2019-05-26 19:15:39 -04:00
Forstride d9be67967d Added Dry Plains biome 2019-05-26 17:33:04 -04:00
Forstride 87d4015726
Update README.md 2019-05-26 04:14:50 -04:00
Forstride 1cd07cb9cf Added missing entities to various biomes 2019-05-26 01:05:14 -04:00
Forstride 1cbe6fbfd9 Allowed palm saplings to grow on sand, Tropics/Volcano tweaks 2019-05-25 20:00:54 -04:00
Forstride 264cec0e33 Fixed water plant itemblock not placing the right block 2019-05-25 18:56:36 -04:00
Forstride ec19709dd6 Various biome improvements, allowed players to spawn in more biomes 2019-05-25 15:31:39 -04:00
Forstride b5318a9126
Merge pull request #1398 from XuyuEre/patch-4
Create zh_cn.json
2019-05-25 14:00:54 -04:00
xuyu0v0 acb363cd40
Create zh_cn.json 2019-05-25 13:43:36 -04:00
Forstride ff0b701098 Fixed willow vine flammability, beaches in Cold Deserts, and various grass/foliage colors 2019-05-25 05:28:12 -04:00
Forstride 142ff6680f Added Igloos/Woodland Mansions to certain biomes 2019-05-25 04:36:50 -04:00
Adubbz 71e656536c Update issue templates 2019-05-25 18:17:56 +10:00
Adubbz f1ac1e8911 Apparently this didn't get pushed 2019-05-25 15:35:03 +10:00
Adubbz 5116a18791 Renaming access transformer 2019-05-25 15:24:40 +10:00
Adubbz f6423c90bb Do curseforge task earlier 2019-05-25 13:53:12 +10:00
Adubbz 2811e8f34e changelog_file, not changelog 2019-05-25 13:49:23 +10:00
Adubbz 9f067691c3 Actually set the curse api key... 2019-05-25 13:43:58 +10:00
Adubbz 0a1cc9b45b Added mainArtifact to curseforge gradle section 2019-05-25 13:36:24 +10:00
Adubbz 077354255b Try this instead 2019-05-25 13:28:35 +10:00
Adubbz f4432d518c Prepare for alpha builds 2019-05-25 13:18:22 +10:00
Adubbz a3c914fa48
Merge pull request #1383 from DaDodger/patch-1
pt_br cleanup
2019-05-25 13:00:53 +10:00
Forstride d0caff2385 Biome tweaks 2019-05-24 22:45:09 -04:00
Forstride b1bf9fabba Added smelting recipes 2019-05-24 22:20:03 -04:00
Forstride 034ea250af Added vanilla blocks to our tag JSONs for the time being until Forge fixes tags 2019-05-24 22:04:20 -04:00
Adubbz ebe61f8930 Revert gradle update 2019-05-25 11:25:12 +10:00
Adubbz ae14dd18e7 Fixed entities 2019-05-25 11:09:26 +10:00
Adubbz 43f4c6c2a7 Updated Forge 2019-05-25 10:31:41 +10:00
Forstride cb522f2675 Fixed flammability for our blocks 2019-05-24 20:18:12 -04:00
Forstride a363ea6b59 Re-added Mangrove 2019-05-24 18:47:51 -04:00
Forstride 7250c168c6 Finished Volcano biome 2019-05-24 16:59:54 -04:00
Forstride b5e6671d1b Island stuff 2019-05-24 07:02:52 -04:00
Adubbz 93dfc32901 Remove debug spam 2019-05-24 19:42:26 +10:00
Adubbz 63389cb46d Generate islands before deep oceans 2019-05-24 19:41:53 +10:00
Forstride af85dd641b Durr 2019-05-24 05:26:00 -04:00
Adubbz a53a6eb2cb Hurr 2019-05-24 19:00:17 +10:00
Adubbz c7720fffb6 Re-added island biomes 2019-05-24 18:48:24 +10:00
Forstride f1fe7a745c River stuff (Too lazy to write a proper commit description) 2019-05-24 01:56:19 -04:00
Adubbz c65d54116c Added support for custom river biomes 2019-05-24 15:35:17 +10:00
Forstride 44795b0e61 Assigned beach biomes to our biomes, generate oceans by climate 2019-05-24 01:20:02 -04:00
Adubbz bb6f283f41 Oops 2019-05-24 14:59:16 +10:00
Adubbz f7e91937d8 Setup for climate-based ocean biomes 2019-05-24 14:51:58 +10:00
Adubbz c739135516 Ensure the beach biome id is actually -1 when the biome is null 2019-05-24 14:27:46 +10:00
Adubbz 5bffc07653 Adjust this too 2019-05-24 14:22:50 +10:00
Adubbz b29ab83903 Fix beach default 2019-05-24 14:22:06 +10:00
Adubbz b68c9522a6 Added support for custom beach biomes 2019-05-24 14:04:04 +10:00
Forstride dfe0c2debf Biome tweaks 2019-05-23 23:51:20 -04:00
Adubbz e3f288ecc6 Added support for custom edge biomes 2019-05-24 13:34:33 +10:00
Adubbz 8ba40c27fd Don't create an instance of BlockWaterTopPlant inline for registration. Fixes a crash on boot 2019-05-24 11:15:48 +10:00
Forstride e004478e3e Re-added reeds and watergrass 2019-05-23 18:26:07 -04:00
Forstride 2e9c5178b2 Biome tweaks 2019-05-23 01:10:10 -04:00
Forstride 0c97c19c1d Tweaked sub-biome rarity 2019-05-22 16:04:48 -04:00
Forstride fbd92d83d5 Allowed the player to spawn in BOP biomes 2019-05-22 02:46:35 -04:00
Forstride 92809f3092 Biome tweaks 2019-05-22 00:43:56 -04:00
Forstride c0739d8f43 Started re-adding boat entities 2019-05-21 22:37:23 -04:00
Forstride fbe6213f7e Removed short grass, tweaked biomes, fixed tree generation block replacement 2019-05-21 21:30:35 -04:00
Forstride 9e8c34618f Implemented saplings properly 2019-05-21 04:42:25 -04:00
Forstride 5d0115f05e Re-added Silkglade 2019-05-21 02:46:28 -04:00
Forstride 7d8b7b65ce Biome tweaks 2019-05-20 20:41:51 -04:00
Forstride 91cf57c696 Re-added Bayou 2019-05-20 17:05:00 -04:00
Forstride 66216018e0 Fixed Bramble 2019-05-19 19:29:23 -04:00
Forstride ca4acfc728 More biome tweaks 2019-05-19 10:32:57 -04:00
Adubbz dc0cab9228 Merge branch 'BOP-1.13-8.x.x' of https://github.com/Glitchfiend/BiomesOPlenty into BOP-1.13-8.x.x 2019-05-19 23:25:48 +10:00
Adubbz 0ff8ae6c7c Added support for subbiomes 2019-05-19 23:25:32 +10:00
Forstride 8d11b2cb25 Tweaked biomes 2019-05-19 09:07:50 -04:00
Adubbz 6c4a11b15e Fixed tpbiome dropping you underneath the world 2019-05-19 20:35:56 +10:00
Adubbz f439032546 Hopefully fixed climates getting clobbered 2019-05-19 20:30:07 +10:00
Forstride 4c68c40904 Re-added most of the remaining overworld biomes, revamped climate mapping 2019-05-18 23:20:31 -04:00
Forstride ada0bd0aa3 Re-added Dead Forest and Grove 2019-05-18 01:58:59 -04:00
Forstride f04d75739a Re-added Cold Desert and Bog Mire 2019-05-17 23:12:49 -04:00
Forstride 97abc07c4a Fixed transparency for leaves in fast graphics 2019-05-14 14:53:48 -04:00
Forstride 289ddbee5f Re-added Brushland, Tundra, and Flower Meadow 2019-05-14 04:17:30 -04:00
Forstride 406b6502df Re-added Shield biome 2019-05-13 19:40:09 -04:00
Forstride d34c3ee723 Re-added Boreal Forest, Pasture, and Prairie 2019-05-13 05:08:42 -04:00
Diego efbe076cf0
pt_br cleanup 2019-05-05 13:54:26 -03:00
Forstride 70eaa49128 Re-added Chaparral 2019-05-04 18:11:38 -04:00
Forstride 9c8e64dacb Tweaked climate mapping 2019-05-04 14:34:57 -04:00
Adubbz 2733f1aba9 Prevent oceans from generating in extreme climates 2019-05-04 22:43:16 +10:00
Adubbz d58be03152 Groovy requires double quotes for format strings 2019-05-04 17:51:02 +10:00
Adubbz 1b4b8cffe0 Another attempt at fixing changelog naming 2019-05-04 17:46:37 +10:00
Adubbz 48a05fb3fe Account for missing changelog for curse 2019-05-04 17:37:42 +10:00
Adubbz 35aeb8afdb Attempt at better changelog naming 2019-05-04 17:32:09 +10:00
Adubbz 102c5e3453 More attempted fixes 2019-05-04 17:27:07 +10:00
Adubbz 51ff1cc235 Oops 2019-05-04 16:01:40 +10:00
Adubbz 5d234873c2 Swap build number for git hash 2019-05-04 15:57:04 +10:00
Adubbz fd3a0e46b0 It would be a good idea to include the password when trying to upload to maven... 2019-05-04 15:44:30 +10:00
Adubbz 9f528f4440 Grep only for lines starting with version 2019-05-04 15:41:27 +10:00
Adubbz 61cfaca544 Fixed maven url 2019-05-04 15:30:06 +10:00
Adubbz 03687501ea Minor fix 2019-05-04 15:25:24 +10:00
Adubbz ec6d959cfe More gradle fixes 2019-05-04 15:15:31 +10:00
Adubbz 4c312894b5 Build updates 2019-05-04 14:59:28 +10:00
Forstride a7db4332eb Re-added Outback and Xeric Shrubland 2019-05-03 23:55:34 -04:00
Forstride 70cfdf7e3a Cleaned some stuff up 2019-05-03 20:08:45 -04:00
Forstride ba27feabf7 Re-added Origin Hills, Snowy Forest, and Temperate Rainforest 2019-05-03 17:47:02 -04:00
Forstride 15ca3613dd Re-added Mystic Grove and Ominous Woods 2019-05-03 15:25:53 -04:00
Forstride 962675faa5 Removed Loamy/Silty/Sandy/Origin grass/dirt/etc. blocks 2019-05-03 14:13:31 -04:00
Forstride 0cbed91d11 Merged Dead Swamp and Bog into a single biome 2019-05-03 13:44:08 -04:00
Adubbz 55a938e8b6 Fixed tiny cacti placement 2019-05-04 00:11:02 +10:00
Forstride 290533131e Re-added Lush Swamp 2019-05-03 03:27:39 -04:00
Adubbz 9f10486989 Merged with Forstride's changes 2019-05-03 16:18:57 +10:00
Forstride 7e662ef79b Re-added Orchard 2019-05-03 01:56:44 -04:00
Forstride 5266a2c112 Redesigned Steppe biome 2019-05-02 23:16:18 -04:00
Forstride b644b75920 Re-added Dead Swamp and Lavender Fields 2019-05-02 17:30:59 -04:00
Forstride 10712027c4 Re-added Seasonal Forest 2019-05-02 15:16:44 -04:00
Forstride 7e9da5e1a7 Started re-adding Wasteland 2019-05-02 13:06:37 -04:00
Adubbz 3eb0516ce1 Re-added twiglets 2019-05-02 22:19:37 +10:00
Adubbz 7f1d083a0b Re-added big tree generation 2019-05-02 19:45:22 +10:00
Forstride ac2c70c097 Re-added Maple Woods 2019-05-01 23:16:51 -04:00
Forstride 072c4c7623 Fixed an issue with climate mapping 2019-05-01 20:21:59 -04:00
Forstride de4e309e53 Re-added Steppe and Tropical Rainforest 2019-05-01 18:39:21 -04:00
Forstride fcbdecd4e8 Re-added Redwood Forest and Alps 2019-05-01 15:17:41 -04:00
Adubbz 4ff264ddfc We don't need the gen layer visualizer atm 2019-05-01 16:34:54 +10:00
Adubbz 443ef45fbe Re-added bop tpbiome 2019-05-01 16:19:29 +10:00
Forstride ab667b9513 Re-added Meadow, Snowy Coniferous Forest, and Woodland 2019-04-30 22:18:04 -04:00
Forstride 581c541073 Re-added Grassland 2019-04-30 18:17:42 -04:00
Forstride d39aa6a42b Re-added Wetland 2019-04-30 17:24:22 -04:00
Forstride 2ce1b15a24 Re-added the Shrubland 2019-04-30 15:35:40 -04:00
Forstride d9534569d7 Started working on adding biomes back 2019-04-30 13:33:10 -04:00
Adubbz 9e9299b665 Updated to 1.13.2 2019-04-30 15:39:42 +10:00
Adubbz e791a36e2f
Merge pull request #1373 from Regnander/patch-2
Create sv_se.json
2019-04-14 07:52:49 +10:00
A. Regnander 764a08eff5
Create sv_se.json 2019-04-13 20:08:55 +02:00
Forstride 5a62b79eff
Merge pull request #1356 from DaDodger/patch-2
Update pt_br.json
2019-03-31 10:33:37 -04:00
Adubbz 8e575c0b54 Re-added mahogany trees 2019-02-24 23:00:17 +11:00
Adubbz 2002152d8a Re-added bushes 2019-02-24 22:05:34 +11:00
Adubbz 6770e18d50 Re-added bulb trees 2019-02-24 21:52:19 +11:00
Adubbz 890f7308db Re-added bayou trees 2019-02-24 21:32:12 +11:00
Adubbz d16d851619 Re-added normal tree gen 2019-02-16 18:28:39 +11:00
Diego 7f65a68525
Update pt_br.json 2019-02-13 17:38:23 -02:00
Adubbz 17dfb6a377 Added fir trees & updated forge 2019-02-09 20:22:58 +11:00
Forstride 7a6abc9022 Updated block bounding boxes 2019-01-28 12:42:52 -05:00
Adubbz 5bb7155286 Updated to new Forge 2019-01-28 11:34:54 +11:00
Adubbz 51ac820532 Update MCP mappings and Forge 2019-01-27 09:50:01 +11:00
Forstride e02cffa5fa
Merge pull request #1348 from DaDodger/patch-1
Create pt_br.json for 1.13
2019-01-23 11:30:49 -05:00
Diego b7b320dfdb
Create pt_br.json for 1.13 2019-01-23 14:12:19 -02:00
Forstride f268aa8552 Fixed some recipes and added tags for more blocks 2019-01-16 06:46:23 -05:00
Adubbz be1b0fb550 Tagged our grass blocks as forge:dirt. Still need to fix canSustainPlant in forge 2019-01-16 12:33:15 +11:00
Forstride ebaa00d0f0 Added grass/foliage coloring for other blocks, moved advancements/recipes to the data folder 2019-01-15 20:04:43 -05:00
Adubbz 90421e3530 Fixed tag loading 2019-01-16 11:54:37 +11:00
Forstride 3ef59f474e Fix merge conflicts 2019-01-16 11:15:30 +11:00
Adubbz 969c7b39e2 Fixed inventory grass colouring 2019-01-16 11:05:25 +11:00
Adubbz 26b1db1c25 Fixed grass block in world colouring 2019-01-16 10:53:45 +11:00
Adubbz 3b076fdc7e Added example biome, generates in world 2019-01-15 10:17:22 +11:00
Adubbz eef4615a2d Hooked up gen layers to the BoP world type 2019-01-14 23:42:13 +11:00
Adubbz 2d25e3d99b Genlayerbiome done 2019-01-14 23:06:01 +11:00
Adubbz 518e6ffe47 Preparations for our custom GenLayerBiome 2019-01-14 22:19:11 +11:00
Adubbz b1d67034dc Fixed dumb climate genlayer bugs 2019-01-14 21:45:55 +11:00
Adubbz 98cba6e62c Climate layer works 2019-01-14 20:21:56 +11:00
Adubbz 65305344f7 GenLayerTemperatureNoise appears to work 2019-01-14 14:05:26 +11:00
Adubbz cd015346de Reverted Forge by 1 version. Seems there's issues with the config changes 2019-01-14 12:02:09 +11:00
Adubbz 8f611d556c Finished cleaning up Mojang's gen layer stuff. Now to do our own. 2019-01-14 11:49:55 +11:00
Forstride 7004b689cd Added proper map colors to blocks 2019-01-14 11:09:39 +11:00
Adubbz 6801ac63e1 More work on genlayers 2019-01-14 11:08:52 +11:00
Adubbz 728044dfba Start on GenLayer stuff 2019-01-14 09:27:50 +11:00
Adubbz ce4e321475 Update Forge 2019-01-14 09:26:05 +11:00
Forstride 5d1328baf2 Added proper map colors to blocks 2019-01-13 13:56:31 -05:00
Adubbz e8de5e822b Use TTFTCUTS colouring for the map thing 2019-01-13 20:23:09 +11:00
Adubbz 4ee56a1f0d Added a genlayer visualizer debug tool 2019-01-13 18:25:05 +11:00
Adubbz ac5010c1eb Commented out farmland blocks because of broken textures, added the bop worldtype (no logic yet, just the worldtype itself) 2019-01-13 15:48:50 +11:00
Adubbz 6548b38ffa Added farmland and grasspath ats 2019-01-13 10:54:47 +11:00
Forstride 8d36d9f5d1 Re-added bramble block 2019-01-12 18:38:58 -05:00
Forstride 088195c315 Started adding grass/dirt blocks, fixed some recipes 2019-01-12 15:49:17 -05:00
Forstride b90b472cc3 Re-added Flesh block, tested particles for flowers 2019-01-12 06:14:49 -05:00
Forstride bb27856827 Remade Dead/Hellbark wood textures 2019-01-12 05:54:41 -05:00
Adubbz f13f692efd Re-added dead wood files 2019-01-12 21:28:05 +11:00
Adubbz 38a8b79fd6 Attempted to add mud particles (currently not working, handleStatusUpdate doesn't appear to be called. Mudballs may not be spawning on the client? 2019-01-12 12:55:10 +11:00
Adubbz 75bf89e31f Attempted to get mudballs working. Seems entity registration is buggy 2019-01-12 11:51:55 +11:00
Forstride a67b28bbd2 Even more stuff 2019-01-11 12:47:31 -05:00
Forstride aa6a51a2f7 More stuff 2019-01-11 10:39:23 -05:00
Adubbz 7e3850538d Actually fixed ATs 2019-01-11 23:17:28 +11:00
Adubbz a975fde9b9 Moar ats 2019-01-11 22:59:28 +11:00
Forstride e5b2431ffb Removed un-needed wood assets 2019-01-11 06:25:22 -05:00
Adubbz 5021731064 Probably better to not leave this in 2019-01-11 22:12:14 +11:00
Adubbz 4ff4ca3508 Added all wooden assets 2019-01-11 22:06:24 +11:00
Forstride 986d6d66f7 Added more fir blocks 2019-01-11 04:33:56 -05:00
Forstride c970e6673a More asset stuff 2019-01-11 03:23:51 -05:00
Adubbz 513f7cd049 Access transformers work properly now, thanks to LexManos. Can now add block sounds and other stuff :) 2019-01-11 16:48:53 +11:00
Adubbz dd140a7dbc Attempted to get access transformers working 2019-01-11 11:37:54 +11:00
Forstride 1cc69438d6 Cleared out existing log/leaf/wood blocks and items 2019-01-10 12:45:02 -05:00
Forstride 771193b7cc Started re-adding plants and stuff 2019-01-10 08:38:29 -05:00
Forstride 5f16ea4eaf Added mud blocks, added remaining methods to ash blocks 2019-01-10 06:26:47 -05:00
Forstride 88f6ea79c6 Removed fruits, updated localization to use JSON format 2019-01-10 05:50:37 -05:00
Adubbz 2b6b856591 Oops 2019-01-10 20:12:41 +11:00
Adubbz e15b139496 Remove old comment 2019-01-10 20:10:22 +11:00
Adubbz 5faec2839c Wanderer now works, reverted texture path changes 2019-01-10 20:06:24 +11:00
Adubbz 68fa0aad3c Updated Forge, added sounds 2019-01-10 19:44:17 +11:00
Adubbz 50cf0f59e1 Re-added the BoP creative tab and the items 2019-01-10 17:28:53 +11:00
Forstride 2ef252f106 Removed unused resources, changed texture folder names, and added trapdoor/stripped log textures for our woods 2019-01-09 10:31:45 -05:00
Adubbz ae5df8f9cd Updated to the new Forge/ForgeGradle 2019-01-09 12:33:02 +11:00
Adubbz ae3bb28a93 Ash block texturing works 2019-01-08 19:47:58 +11:00
Adubbz 87c73863f8 Re-added 7.1.0 assets 2019-01-08 18:52:27 +11:00
Adubbz 5d011224b5 Rollback forge gradle, the new version is broken 2019-01-08 18:50:41 +11:00
Adubbz 5f7015aeee Basic block registration works 2019-01-07 22:23:07 +11:00
Adubbz 7f6ace64e9 Mod now loads. Doesn't actually do anything (yet) 2019-01-07 19:35:58 +11:00
Adubbz 57ac719093 Preliminary gradle fixing. Have I ever mentioned that I think Gradle is rubbish? 2019-01-07 17:13:56 +11:00
4699 changed files with 59387 additions and 70804 deletions

View File

@ -1,79 +0,0 @@
--------------------------------------------------------------------------------
**BEFORE SUBMITTING!**
You must ensure the following before reporting an issue with the mod.
For feature requests, you may delete this template and create your own.
--------------------------------------------------------------------------------
- [ ] Biomes O' Plenty is updated to the latest available version.
- [ ] This issue occurs with Minecraft 1.12.
**We *DO NOT* support Minecraft versions 1.7.10, 1.8.9, 1.9.4, 1.10.2, 1.11 or anything below that!**
**YOUR ISSUE WILL AUTOMATICALLY BE CLOSED IF IT IS PERTAINING TO THOSE VERSIONS!**
--------------------------------------------------------------------------------
- [ ] Forge is updated to the latest available version.
- [ ] This issue occurs *WITHOUT* Optifine, Sponge or similar mods installed.
**Mods such as Optifine and Sponge interfere with the normal functioning of the game by modifying its code.**
**We do not support these mods in any way as they can introduce bugs which would not normally be present with**
**only Forge installed.**
--------------------------------------------------------------------------------
- [ ] This issue can be reproduced with ONLY Biomes O' Plenty and any other affected mods.
- [ ] All other mods which appear to be involved are updated to their latest versions.
- [ ] I have included any relevant logs and screenshots below.
**If this is a compatibility issue with another mod, you *MUST* test with *ONLY* Biomes O' Plenty and that specific mod.**
**Logs containing masses of mods are extremely unhelpful, and it is unlikely that your issue will be addressed.**
--------------------------------------------------------------------------------
- [ ] This issue does not occur in a modpack.
**Issues with modpacks should be reported to the modpack author(s). As noted above, mod compatibility issues must**
**occur with the latest versions of both Biomes O' Plenty and the affected mod.**
**The issue *MUST* be tested with *ONLY* Biomes O' Plenty and the affected mod.**
--------------------------------------------------------------------------------
*Once you have read and verified the above, you may delete all text up to this point.*
#### Issue Description:
#### Steps to reproduce:
1.
2.
3.
#### Additional Information:
- fml-client-latest.log or fml-server-latest.log:
- Screenshots:
____
#### Affected Versions (Exact numbers, do *NOT* use "latest"):
- Biomes O' Plenty:
- Minecraft:
- Forge:

View File

@ -0,0 +1,27 @@
---
name: 1.16.3 Standalone Bug
about: For bugs that occur with Biomes O' Plenty for 1.16.3. We do not support older versions!
title: ''
labels: bug-minor
assignees: ''
---
## Bug Report
[ Lines between [ ] (square brackets) should be removed before posting. ]</br>
### What's the issue you encountered?
[ Describe the issue in detail and what you were doing beforehand. ]</br>
### How can the issue be reproduced?
[ Include a detailed step by step process for recreating your issue with only Biomes O' Plenty installed. ]</br>
### Logs
[ Please include any relevant logs here. This can be done by dragging and dropping your log files into the issue. ]</br>
### Mod Version
[ Please put the version of the mod you were using here. ]</br>

View File

@ -0,0 +1,23 @@
---
name: 1.16.3 Standalone Crash
about: For crashes that occur with Biomes O' Plenty for 1.16.3. We do not support older versions!
title: ''
labels: crash
assignees: ''
---
## Bug Report
[ Lines between [ ] (square brackets) should be removed before posting. ]</br>
### How can the crash be reproduced?
[ Include a detailed step by step process for recreating your crash with only Biomes O' Plenty installed. ]</br>
### Crash Report and Logs
[ Please include your crash report and logs here. This can be done by dragging and dropping your log files and crash report files into the issue. ]</br>
### Mod Version
[ Please put the version of the mod you were using here. ]</br>

View File

@ -0,0 +1,20 @@
---
name: 1.16.3 Feature Request
about: Feature requests for Biomes O' Plenty for 1.16.3. We do not support older versions!
title: ''
labels: feature
assignees: ''
---
## Feature Request
[ Lines between [ ] (square brackets) should be removed before posting. ]</br>
### What feature are you suggesting?
[ Provide an overview of the feature being suggested. ]</br>
### Why should it be added?
[ Describe the benefits of implementing this feature. ]</br>

5
.github/ISSUE_TEMPLATE/config.yml vendored Normal file
View File

@ -0,0 +1,5 @@
blank_issues_enabled: false
contact_links:
- name: Glitchfiend Discord
url: https://discord.gg/GyyzU6T
about: Please ask general questions here instead of opening issues for them.

8
.gitignore vendored
View File

@ -4,6 +4,7 @@
/Mixin/
/repo/
/run/
/logs/
.idea/*
/.gradle/
/.settings/
@ -18,3 +19,10 @@
*.ipr
*.iws
*.launch
mappings/.gradle/
#mappings/mcp/
mappings/build/
mappings/*.csv
mappings/.project
mappings/last_updated.json

60
Jenkinsfile vendored Normal file
View File

@ -0,0 +1,60 @@
@Library('forge-shared-library')_
pipeline {
options {
disableConcurrentBuilds()
}
agent {
docker {
image 'gradle:jdk8'
args '-v forgegc:/home/gradle/.gradle/'
}
}
environment {
GRADLE_ARGS = '--no-daemon --console=plain' // No daemon for now as FG3 kinda derps. //'-Dorg.gradle.daemon.idletimeout=5000'
JENKINS_HEAD = 'https://wiki.jenkins-ci.org/download/attachments/2916393/headshot.png'
}
stages {
stage('fetch') {
steps {
checkout scm
}
}
stage('setup') {
steps {
withGradle {
sh './gradlew ${GRADLE_ARGS} --refresh-dependencies'
}
script {
env.MYVERSION = sh(returnStdout: true, script: './gradlew :properties -q | grep "^version:" | awk \'{print $2}\'').trim()
}
}
}
stage('changelog') {
when {
not {
changeRequest()
}
}
steps {
writeChangelog(currentBuild, "build/BiomesOPlenty-${env.MYVERSION}-changelog.txt")
}
}
stage('publish') {
when {
not {
changeRequest()
}
}
environment {
CURSE_API_KEY = credentials('curse-api-key')
}
steps {
withGradle {
sh './gradlew ${GRADLE_ARGS} :uploadArchives curseforge -PcurseApiKey=${CURSE_API_KEY}'
}
}
}
}
}

View File

@ -1,21 +1,17 @@
<p align="center"><img src="http://i.imgur.com/uP9GBEb.png"></p>
<p align="center"><img src="https://i.imgur.com/HQ2opH6.png"></p>
**Biomes O' Plenty** is a **Minecraft mod** that adds **over 50 new biomes** to the overworld and Nether. From coral reefs to bamboo forests, all of our biomes are decorated with a slew of **new plants, trees, flowers, and more!**
<p align="center"><img src="https://i.imgur.com/CYxKg5M.png"></p>
<p align="center">https://discord.gg/GyyzU6T</p>
**Biomes O' Plenty** is a **Minecraft mod** that adds **over 50 new biomes** to the Overworld, Nether, and End. From Lavender Fields to Redwood Forests and many more, all of our biomes are decorated with a variety of **new trees, flowers, and plants!**
-----------------
**Note:** To use the mod on a **server**, you must set the **level-type** setting in your server's config file to **BIOMESOP**
If you want to **disable or add certain world generation features** in certain biomes, check out our guide for creating **biome configuration files**: https://github.com/Glitchfiend/BiomesOPlenty/wiki/Configuring-Biomes
**Note:** To use the mod on a **server**, you must set the **level-type** setting in your server's config file to **biomesoplenty**
-----------------
[<img src="http://i.creativecommons.org/l/by-nc-nd/3.0/88x31.png">](http://creativecommons.org/licenses/by-nc-nd/4.0/deed.en_US)
Biomes O' Plenty is licensed under a [Creative Commons Attribution-NonCommercial-NoDerivs 4.0 Unported License](http://creativecommons.org/licenses/by-nc-nd/4.0/deed.en_US).
-----------------
We've partnered with **CreeperHost**, and have our very own **promo code** that you can use when ordering a server of your own!
<p align="center"><img src="http://i.imgur.com/rjmyjrV.png"></p>
Biomes O' Plenty is licensed under a [Creative Commons Attribution-NonCommercial-NoDerivs 4.0 Unported License](http://creativecommons.org/licenses/by-nc-nd/4.0/deed.en_US).

View File

@ -1,100 +1,71 @@
buildscript {
repositories {
mavenLocal()
maven { url = 'https://files.minecraftforge.net/maven' }
jcenter()
maven {
name = "forge"
url = "http://files.minecraftforge.net/maven"
}
mavenCentral()
}
dependencies {
classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
}
}
plugins {
id "com.matthewprenger.cursegradle" version "1.0.9"
id "com.matthewprenger.cursegradle" version "1.4.0"
}
apply plugin: 'net.minecraftforge.gradle.forge'
apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: 'maven'
// define the properties file
ext.configFile = file "build.properties"
configFile.withReader {
// read config. it shall from now on be referenced as simply config or as project.config
def prop = new Properties()
prop.load(it)
project.ext.config = new ConfigSlurper().parse prop
}
repositories { mavenLocal() }
group = "com.github.glitchfiend.biomesoplenty"
// why set the version twice?
version = config.mod_version
archivesBaseName = "BiomesOPlenty"
// add some stuff to the version
version = "${config.minecraft_version}-${config.mod_version}.${System.getenv().BUILD_NUMBER}"
// set this for the version.properties file, or was this broken on purpose?
config.build_number = (System.getenv().BUILD_NUMBER) ? System.getenv().BUILD_NUMBER : ""
def getGitHash = {
def stdout = new ByteArrayOutputStream()
exec {
commandLine 'git', 'rev-parse', '--short', 'HEAD'
standardOutput = stdout
}
return stdout.toString().trim()
}
version = "${minecraft_version}-${mod_version}.${System.getenv().BUILD_NUMBER}"
minecraft {
version = config.minecraft_version + "-" + config.forge_version // grab latest forge
useDepAts = true
mappings = project.config.mappings_version
//gradle complains if this isn't set when setting up/using IDEA workspace
runDir = "run"
//set a full version string with appended build number to be used in mod registration
def buildnum = (config.build_number!="") ? '.' + config.build_number : ""
replace '@MOD_VERSION@', config.mod_version + buildnum
replace '1.0.0.0', config.forge_version
replaceIn 'BiomesOPlenty.java'
}
mappings channel: 'official', version: minecraft_version
def commonManifest = {
attributes 'FMLAT': 'biomesoplenty_at.cfg'
}
accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
jar {
manifest commonManifest
classifier = 'universal'
runs {
client = {
workingDirectory = project.file("run").canonicalPath
source sourceSets.main
}
server = {
workingDirectory = project.file("run").canonicalPath
source sourceSets.main
}
}
}
processResources {
from(sourceSets.main.resources.srcDirs) {
include '**/*.info'
include '**/*.properties'
// replaces
expand ([
'modid': project.archivesBaseName,
'mod_version': project.config.mod_version,
'minecraft_version': project.config.minecraft_version,
'build_number': project.config.build_number
])
}
from(sourceSets.main.resources.srcDirs) {
exclude '**/*.info'
exclude '**/*.properties'
from (sourceSets.main.resources.srcDirs) {
include 'META-INF/mods.toml'
expand 'version': project.version
}
}
import groovy.io.FileType
task changelog(type: JenkinsChangelog) {
def buildNumber = "${System.getenv().BUILD_NUMBER}"
serverRoot = 'http://ci.jenkins.minecraftforge.net/'
jobName = 'BiomesOPlenty'
authName = 'console_script'
authPassword = 'dc6d48ca20a474beeac280a9a16a926e'
targetBuild = buildNumber.toString()
output = 'build/libs/' + project.getName() + '-' + project.version + '-changelog.txt'
jar {
classifier = 'universal'
}
tasks.build.dependsOn('changelog')
dependencies {
minecraft 'net.minecraftforge:forge:' + minecraft_version + '-' + forge_version
}
task sourcesJar(type: Jar) {
from sourceSets.main.allJava
@ -107,8 +78,6 @@ task sourcesJar(type: Jar) {
task deobfJar(type: Jar) {
from sourceSets.main.output
manifest commonManifest
classifier = 'deobf'
}
@ -124,57 +93,49 @@ task apiJar(type: Jar) {
classifier = 'api'
}
task listOutputs << {
//This is needed by the Groovy Postbuild to append labels for each build used in the changelog.
println "Output files:"
println "--------------------"
def list = []
def dir = new File("build/libs/")
if (dir.exists()) {
dir.eachFileRecurse (FileType.FILES) { file ->
//Add each file to the list
list << file
}
//Print the names of all of the output files
list.each {
println it.getName()
}
}
println "--------------------"
}
tasks.build.finalizedBy('listOutputs')
artifacts {
archives changelog.output
archives sourcesJar
archives deobfJar
archives apiJar
}
def changelog_file = rootProject.file("build/BiomesOPlenty-${version}-changelog.txt")
curseforge {
apiKey = "$System.env.curse_api_key"
project {
id = '220318'
changelog = file('build/libs/' + project.getName() + '-' + project.version + '-changelog.txt')
releaseType = 'beta'
if (project.hasProperty('curseApiKey')) {
apiKey = project.getProperty('curseApiKey')
project {
id = '220318'
if (changelog_file.exists()) {
changelog = changelog_file
}
releaseType = 'beta'
mainArtifact(jar) {
displayName = "Biomes O' Plenty ${version}"
}
addArtifact sourcesJar
addArtifact deobfJar
addArtifact apiJar
}
}
}
artifacts {
if (changelog_file.exists()) {
archives changelog_file
}
archives jar
archives sourcesJar
archives deobfJar
archives apiJar
}
uploadArchives {
repositories {
mavenDeployer {
if (project.hasProperty('forgeMavenPassword'))
{
if (project.hasProperty('forgeMavenPassword')) {
repository(url: "https://files.minecraftforge.net/maven/manage/upload") {
authentication(userName: project.getProperty('forgeMavenUsername'), password: project.getProperty('forgeMavenPassword'))
}
}
else
{
else {
// local repo folder. Might wanna juset use gradle install if you wanans end it to maven-local
repository(url: 'file://localhost/' + project.file('repo').getAbsolutePath())
}
@ -214,21 +175,11 @@ uploadArchives {
name 'Adubbz'
roles { role 'developer' }
}
developer {
id 'Amnet'
name 'Amnet'
roles { role 'developer' }
}
developer {
id 'Forstride'
name 'Forstride'
roles { role 'developer' }
}
developer {
id 'ted80'
name 'ted80'
roles { role 'developer' }
}
}
}
}

View File

@ -1,4 +0,0 @@
minecraft_version=1.12.2
forge_version=14.23.5.2768
mod_version=7.0.1
mappings_version=snapshot_nodoc_20171031

12
gradle.properties Normal file
View File

@ -0,0 +1,12 @@
# Sets default memory used for gradle commands. Can be overridden by user or command line properties.
# This is required to provide enough memory for the Minecraft decompilation process.
org.gradle.jvmargs=-Xmx3G
org.gradle.daemon=false
mod_version=13.1.0
minecraft_version=1.16.5
minecraft_version_toml=16
forge_version=36.1.0
forge_version_toml=36
forge_group=net.minecraftforge

Binary file not shown.

View File

@ -1,6 +1,5 @@
#Thu Nov 17 11:57:30 EST 2016
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.9-bin.zip
distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-bin.zip

98
gradlew vendored
View File

@ -6,42 +6,6 @@
##
##############################################################################
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn ( ) {
echo "$*"
}
die ( ) {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
esac
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
@ -60,6 +24,46 @@ cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
@ -85,7 +89,7 @@ location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@ -150,11 +154,19 @@ if $cygwin ; then
esac
fi
# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
function splitJvmOpts() {
JVM_OPTS=("$@")
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
APP_ARGS=$(save "$@")
exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
cd "$(dirname "$0")"
fi
exec "$JAVACMD" "$@"

View File

@ -1,65 +0,0 @@
/**
* This class was created by <Vazkii>. It's distributed as
* part of the Botania Mod. Get the Source Code in github:
* https://github.com/Vazkii/Botania
*
* Botania is Open Source and distributed under the
* Botania License: http://botaniamod.net/license.php
*
* File Created @ [Oct 24, 2015, 11:16:00 PM (GMT)]
*/
package vazkii.botania.api.item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
/**
* A Block that implements this can be uprooted by the various horns in Botania.
*/
public interface IHornHarvestable {
/**
* Returns true if this block can be uprooted.
* Note that the stack param can be null if it's a drum breaking it.
*/
boolean canHornHarvest(World world, BlockPos pos, ItemStack stack, EnumHornType hornType);
/**
* Returns true if harvestByHorn() should be called. If false it just uses the normal
* block breaking method.
* Note that the stack param can be null if it's a drum breaking it.
*/
boolean hasSpecialHornHarvest(World world, BlockPos pos, ItemStack stack, EnumHornType hornType);
/**
* Called to harvest by a horn.
* Note that the stack param can be null if it's a drum breaking it.
*/
void harvestByHorn(World world, BlockPos pos, ItemStack stack, EnumHornType hornType);
enum EnumHornType {
/**
* Horn of the Wild, for grass and crops
*/
WILD,
/**
* Horn of the Canopy, for leaves
*/
CANOPY,
/**
* Horn of the Covering, for snow
*/
COVERING;
public static EnumHornType getTypeForMeta(int meta) {
EnumHornType[] values = EnumHornType.values();
return values[Math.min(values.length - 1, meta)];
}
}
}

View File

@ -1,161 +1,104 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.biome;
import java.util.List;
import com.google.common.base.Optional;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import net.minecraft.world.WorldType;
import biomesoplenty.core.BiomesOPlenty;
import net.minecraft.util.RegistryKey;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.registry.Registry;
import net.minecraft.world.biome.Biome;
public class BOPBiomes
{
public static final IBiomeRegistry REG_INSTANCE = createRegistry();
/**A list of world types where BoP biome decoration does not occur**/
public static List<WorldType> excludedDecoratedWorldTypes = Lists.newArrayList();
// normal biomes which have weights
public static Optional<Biome> alps = Optional.absent();
public static Optional<Biome> bamboo_forest = Optional.absent();
public static Optional<Biome> bayou = Optional.absent();
public static Optional<Biome> bog = Optional.absent();
public static Optional<Biome> boreal_forest = Optional.absent();
public static Optional<Biome> brushland = Optional.absent();
public static Optional<Biome> chaparral = Optional.absent();
public static Optional<Biome> cherry_blossom_grove = Optional.absent();
public static Optional<Biome> cold_desert = Optional.absent();
public static Optional<Biome> coniferous_forest = Optional.absent();
public static Optional<Biome> crag = Optional.absent();
public static Optional<Biome> dead_forest = Optional.absent();
public static Optional<Biome> dead_swamp = Optional.absent();
public static Optional<Biome> eucalyptus_forest = Optional.absent();
public static Optional<Biome> fen = Optional.absent();
public static Optional<Biome> flower_field = Optional.absent();
public static Optional<Biome> grassland = Optional.absent();
public static Optional<Biome> grove = Optional.absent();
public static Optional<Biome> highland = Optional.absent();
public static Optional<Biome> land_of_lakes = Optional.absent();
public static Optional<Biome> lavender_fields = Optional.absent();
public static Optional<Biome> lush_desert = Optional.absent();
public static Optional<Biome> lush_swamp = Optional.absent();
public static Optional<Biome> mangrove = Optional.absent();
public static Optional<Biome> maple_woods = Optional.absent();
public static Optional<Biome> marsh = Optional.absent();
public static Optional<Biome> meadow = Optional.absent();
public static Optional<Biome> moor = Optional.absent();
public static Optional<Biome> mountain = Optional.absent();
public static Optional<Biome> mystic_grove = Optional.absent();
public static Optional<Biome> ominous_woods = Optional.absent();
public static Optional<Biome> orchard = Optional.absent();
public static Optional<Biome> outback = Optional.absent();
public static Optional<Biome> overgrown_cliffs = Optional.absent();
public static Optional<Biome> prairie = Optional.absent();
public static Optional<Biome> quagmire = Optional.absent();
public static Optional<Biome> rainforest = Optional.absent();
public static Optional<Biome> redwood_forest = Optional.absent();
public static Optional<Biome> sacred_springs = Optional.absent();
public static Optional<Biome> seasonal_forest = Optional.absent();
public static Optional<Biome> shield = Optional.absent();
public static Optional<Biome> shrubland = Optional.absent();
public static Optional<Biome> snowy_coniferous_forest = Optional.absent();
public static Optional<Biome> snowy_forest = Optional.absent();
public static Optional<Biome> steppe = Optional.absent();
public static Optional<Biome> temperate_rainforest = Optional.absent();
public static Optional<Biome> tropical_rainforest = Optional.absent();
public static Optional<Biome> tundra = Optional.absent();
public static Optional<Biome> wasteland = Optional.absent();
public static Optional<Biome> wetland = Optional.absent();
public static Optional<Biome> woodland = Optional.absent();
public static Optional<Biome> xeric_shrubland = Optional.absent();
// edge-biomes, sub-biomes and mutated-biomes
public static Optional<Biome> alps_foothills = Optional.absent();
public static Optional<Biome> mountain_foothills = Optional.absent();
public static Optional<Biome> redwood_forest_edge = Optional.absent();
public static Optional<Biome> pasture = Optional.absent();
public static Optional<Biome> glacier = Optional.absent();
public static Optional<Biome> oasis = Optional.absent();
public static Optional<Biome> snowy_tundra = Optional.absent();
public static Optional<Biome> coral_reef = Optional.absent();
public static Optional<Biome> kelp_forest = Optional.absent();
public static Optional<Biome> origin_island = Optional.absent();
public static Optional<Biome> tropical_island = Optional.absent();
public static Optional<Biome> volcanic_island = Optional.absent();
public static Optional<Biome> flower_island = Optional.absent();
public static Optional<Biome> gravel_beach = Optional.absent();
public static Optional<Biome> white_beach = Optional.absent();
public static Optional<Biome> origin_beach = Optional.absent();
public static RegistryKey<Biome> alps = register("alps");
public static RegistryKey<Biome> alps_foothills = register("alps_foothills");
public static RegistryKey<Biome> bamboo_blossom_grove = register("bamboo_blossom_grove");
public static RegistryKey<Biome> bayou = register("bayou");
public static RegistryKey<Biome> bayou_mangrove = register("bayou_mangrove");
public static RegistryKey<Biome> burnt_forest = register("burnt_forest");
public static RegistryKey<Biome> cherry_blossom_grove = register("cherry_blossom_grove");
public static RegistryKey<Biome> cold_desert = register("cold_desert");
public static RegistryKey<Biome> coniferous_forest = register("coniferous_forest");
public static RegistryKey<Biome> coniferous_lakes = register("coniferous_lakes");
public static RegistryKey<Biome> dead_forest = register("dead_forest");
public static RegistryKey<Biome> deep_bayou = register("deep_bayou");
public static RegistryKey<Biome> dense_marsh = register("dense_marsh");
public static RegistryKey<Biome> dense_woodland = register("dense_woodland");
public static RegistryKey<Biome> dryland = register("dryland");
public static RegistryKey<Biome> dry_boneyard = register("dry_boneyard");
public static RegistryKey<Biome> fir_clearing = register("fir_clearing");
public static RegistryKey<Biome> flower_meadow = register("flower_meadow");
public static RegistryKey<Biome> fungal_field = register("fungal_field");
public static RegistryKey<Biome> fungal_jungle = register("fungal_jungle");
public static RegistryKey<Biome> golden_prairie = register("golden_prairie");
public static RegistryKey<Biome> grassland = register("grassland");
public static RegistryKey<Biome> grassland_clover_patch = register("grassland_clover_patch");
public static RegistryKey<Biome> gravel_beach = register("gravel_beach");
public static RegistryKey<Biome> grove = register("grove");
public static RegistryKey<Biome> grove_clearing = register("grove_clearing");
public static RegistryKey<Biome> grove_lakes = register("grove_lakes");
public static RegistryKey<Biome> highland = register("highland");
public static RegistryKey<Biome> highland_crag = register("highland_crag");
public static RegistryKey<Biome> highland_moor = register("highland_moor");
public static RegistryKey<Biome> jade_cliffs = register("jade_cliffs");
public static RegistryKey<Biome> lavender_field = register("lavender_field");
public static RegistryKey<Biome> lavender_forest = register("lavender_forest");
public static RegistryKey<Biome> lush_desert = register("lush_desert");
public static RegistryKey<Biome> lush_savanna = register("lush_savanna");
public static RegistryKey<Biome> marsh = register("marsh");
public static RegistryKey<Biome> meadow = register("meadow");
public static RegistryKey<Biome> meadow_forest = register("meadow_forest");
public static RegistryKey<Biome> muskeg = register("muskeg");
public static RegistryKey<Biome> mystic_grove = register("mystic_grove");
public static RegistryKey<Biome> mystic_plains = register("mystic_plains");
public static RegistryKey<Biome> ominous_woods = register("ominous_woods");
public static RegistryKey<Biome> ominous_mire = register("ominous_mire");
public static RegistryKey<Biome> orchard = register("orchard");
public static RegistryKey<Biome> origin_valley = register("origin_valley");
public static RegistryKey<Biome> prairie = register("prairie");
public static RegistryKey<Biome> rainbow_hills = register("rainbow_hills");
public static RegistryKey<Biome> rainforest = register("rainforest");
public static RegistryKey<Biome> rainforest_cliffs = register("rainforest_cliffs");
public static RegistryKey<Biome> rainforest_floodplain = register("rainforest_floodplain");
public static RegistryKey<Biome> redwood_forest = register("redwood_forest");
public static RegistryKey<Biome> redwood_forest_edge = register("redwood_forest_edge");
public static RegistryKey<Biome> redwood_hills = register("redwood_hills");
public static RegistryKey<Biome> scrubland = register("scrubland");
public static RegistryKey<Biome> seasonal_forest = register("seasonal_forest");
public static RegistryKey<Biome> seasonal_orchard = register("seasonal_orchard");
public static RegistryKey<Biome> seasonal_pumpkin_patch = register("seasonal_pumpkin_patch");
public static RegistryKey<Biome> shroomy_wetland = register("shroomy_wetland");
public static RegistryKey<Biome> shrubland = register("shrubland");
public static RegistryKey<Biome> shrubland_hills = register("shrubland_hills");
public static RegistryKey<Biome> snowy_coniferous_forest = register("snowy_coniferous_forest");
public static RegistryKey<Biome> snowy_fir_clearing = register("snowy_fir_clearing");
public static RegistryKey<Biome> snowy_maple_forest = register("snowy_maple_forest");
public static RegistryKey<Biome> tall_dead_forest = register("tall_dead_forest");
public static RegistryKey<Biome> tropic_beach = register("tropic_beach");
public static RegistryKey<Biome> tropics = register("tropics");
public static RegistryKey<Biome> tundra = register("tundra");
public static RegistryKey<Biome> tundra_basin = register("tundra_basin");
public static RegistryKey<Biome> tundra_bog = register("tundra_bog");
public static RegistryKey<Biome> volcanic_plains = register("volcanic_plains");
public static RegistryKey<Biome> volcano = register("volcano");
public static RegistryKey<Biome> wasteland = register("wasteland");
public static RegistryKey<Biome> wetland = register("wetland");
public static RegistryKey<Biome> wetland_forest = register("wetland_forest");
public static RegistryKey<Biome> wooded_scrubland = register("wooded_scrubland");
public static RegistryKey<Biome> woodland = register("woodland");
// nether biomes
public static Optional<Biome> corrupted_sands = Optional.absent();
public static Optional<Biome> fungi_forest = Optional.absent();
public static Optional<Biome> phantasmagoric_inferno = Optional.absent();
public static Optional<Biome> undergarden = Optional.absent();
public static Optional<Biome> visceral_heap = Optional.absent();
public static RegistryKey<Biome> crystalline_chasm = register("crystalline_chasm");
public static RegistryKey<Biome> undergrowth = register("undergrowth");
public static RegistryKey<Biome> visceral_heap = register("visceral_heap");
public static RegistryKey<Biome> withered_abyss = register("withered_abyss");
//Biome extensions
public static IExtendedBiome end_extension;
public static IExtendedBiome mushroom_island_extension;
public static IExtendedBiome plains_extension;
public static IExtendedBiome flower_forest_extension;
public static IExtendedBiome forest_extension;
public static IExtendedBiome forest_hills_extension;
public static IExtendedBiome jungle_extension;
public static IExtendedBiome jungle_hills_extension;
public static IExtendedBiome desert_extension;
public static IExtendedBiome desert_hills_extension;
public static IExtendedBiome taiga_extension;
public static IExtendedBiome taiga_hills_extension;
public static IExtendedBiome mesa_extension;
public static IExtendedBiome mesa_plateau_extension;
public static IExtendedBiome ice_plains_extension;
public static IExtendedBiome ice_mountains_extension;
public static IExtendedBiome extreme_hills_extension;
public static IExtendedBiome extreme_hills_plus_extension;
public static IExtendedBiome swampland_extension;
public static IExtendedBiome birch_forest_extension;
public static IExtendedBiome birch_forest_hills_extension;
public static IExtendedBiome roofed_forest_extension;
public static IExtendedBiome savanna_extension;
public static IExtendedBiome savanna_plateau_extension;
public static IExtendedBiome ocean_extension;
public static IExtendedBiome cold_taiga_extension;
public static IExtendedBiome cold_taiga_hills_extension;
public static IExtendedBiome mega_taiga_extension;
public static IExtendedBiome mega_taiga_hills_extension;
public static IExtendedBiome hell_extension;
public static IExtendedBiome beach_extension;
private static IBiomeRegistry createRegistry()
private static RegistryKey<Biome> register(String name)
{
IBiomeRegistry instance = null;
try
{
instance = (IBiomeRegistry)Class.forName("biomesoplenty.common.init.ModBiomes").newInstance();
}
catch (Exception e)
{
e.printStackTrace();
}
return instance;
}
public interface IBiomeRegistry
{
IExtendedBiome registerBiome(IExtendedBiome biome, String idName);
IExtendedBiome getExtendedBiome(Biome biome);
ImmutableSet<Biome> getPresentBiomes();
return RegistryKey.create(Registry.BIOME_REGISTRY, new ResourceLocation(BiomesOPlenty.MOD_ID, name));
}
}

View File

@ -1,14 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.biome;
public enum BiomeOwner
{
BIOMESOPLENTY, OTHER
}

View File

@ -1,39 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.biome;
import java.util.Map;
import biomesoplenty.api.config.IBOPWorldSettings;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.api.generation.IGenerationManager;
import biomesoplenty.api.generation.IGenerator;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.biome.Biome;
public interface IExtendedBiome
{
void applySettings(IBOPWorldSettings settings);
void configure(IConfigObj conf);
BiomeOwner getBiomeOwner();
void addGenerator(String name, GeneratorStage stage, IGenerator generator);
IGenerationManager getGenerationManager();
Map<BOPClimates, Integer> getWeightMap();
void clearWeights();
void addWeight(BOPClimates climate, int weight);
ResourceLocation getBeachLocation();
/**Get the base biome associated with this extension**/
Biome getBaseBiome();
ResourceLocation getResourceLocation();
}

View File

@ -1,159 +1,346 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.block;
import net.minecraft.block.Block;
import net.minecraftforge.fluids.Fluid;
public class BOPBlocks
{
public static Block bamboo_thatching;
public static Block ash_block;
public static Block white_sand;
public static Block bamboo;
public static Block coral;
public static Block seaweed;
public static Block gem_block;
public static Block gem_ore;
public static Block hive;
public static Block mushroom;
public static Block white_sandstone;
public static Block biome_block;
public static Block blue_fire;
public static Block flower_0;
public static Block flower_1;
public static Block log_0;
public static Block log_1;
public static Block log_2;
public static Block log_3;
public static Block log_4;
public static Block leaves_0;
public static Block leaves_1;
public static Block leaves_2;
public static Block leaves_3;
public static Block leaves_4;
public static Block leaves_5;
public static Block leaves_6;
public static Block sapling_0;
public static Block sapling_1;
public static Block sapling_2;
// TODO fruit tree leaves and saplings
public static Block planks_0;
public static Block wood_slab_0;
public static Block wood_slab_1;
public static Block double_wood_slab_0;
public static Block double_wood_slab_1;
public static Block sacred_oak_stairs;
public static Block cherry_stairs;
public static Block umbran_stairs;
public static Block fir_stairs;
public static Block ethereal_stairs;
public static Block magic_stairs;
public static Block mangrove_stairs;
public static Block palm_stairs;
public static Block redwood_stairs;
public static Block willow_stairs;
public static Block pine_stairs;
public static Block hellbark_stairs;
public static Block jacaranda_stairs;
public static Block mahogany_stairs;
public static Block ebony_stairs;
public static Block eucalyptus_stairs;
public static Block sacred_oak_fence;
public static Block cherry_fence;
public static Block umbran_fence;
public static Block fir_fence;
public static Block ethereal_fence;
public static Block magic_fence;
public static Block mangrove_fence;
public static Block palm_fence;
public static Block redwood_fence;
public static Block willow_fence;
public static Block pine_fence;
public static Block hellbark_fence;
public static Block jacaranda_fence;
public static Block mahogany_fence;
public static Block ebony_fence;
public static Block eucalyptus_fence;
public static Block sacred_oak_fence_gate;
public static Block cherry_fence_gate;
public static Block umbran_fence_gate;
public static Block fir_fence_gate;
public static Block ethereal_fence_gate;
public static Block magic_fence_gate;
public static Block mangrove_fence_gate;
public static Block palm_fence_gate;
public static Block redwood_fence_gate;
public static Block willow_fence_gate;
public static Block pine_fence_gate;
public static Block hellbark_fence_gate;
public static Block jacaranda_fence_gate;
public static Block mahogany_fence_gate;
public static Block ebony_fence_gate;
public static Block eucalyptus_fence_gate;
public static Block sacred_oak_door;
public static Block cherry_door;
public static Block umbran_door;
public static Block fir_door;
public static Block ethereal_door;
public static Block magic_door;
public static Block mangrove_door;
public static Block palm_door;
public static Block redwood_door;
public static Block willow_door;
public static Block pine_door;
public static Block hellbark_door;
public static Block jacaranda_door;
public static Block mahogany_door;
public static Block ebony_door;
public static Block eucalyptus_door;
public static Block cut_white_sandstone;
public static Block cut_white_sandstone_slab;
public static Block chiseled_white_sandstone;
public static Block smooth_white_sandstone;
public static Block smooth_white_sandstone_slab;
public static Block smooth_white_sandstone_stairs;
public static Block white_sandstone_slab;
public static Block white_sandstone_stairs;
public static Block white_sandstone_wall;
public static Block orange_sand;
public static Block orange_sandstone;
public static Block cut_orange_sandstone;
public static Block cut_orange_sandstone_slab;
public static Block chiseled_orange_sandstone;
public static Block smooth_orange_sandstone;
public static Block smooth_orange_sandstone_slab;
public static Block smooth_orange_sandstone_stairs;
public static Block orange_sandstone_slab;
public static Block orange_sandstone_stairs;
public static Block orange_sandstone_wall;
public static Block black_sand;
public static Block black_sandstone;
public static Block cut_black_sandstone;
public static Block cut_black_sandstone_slab;
public static Block chiseled_black_sandstone;
public static Block smooth_black_sandstone;
public static Block smooth_black_sandstone_slab;
public static Block smooth_black_sandstone_stairs;
public static Block black_sandstone_slab;
public static Block black_sandstone_stairs;
public static Block black_sandstone_wall;
public static Block mud;
public static Block flesh;
public static Block grass;
public static Block grass_path;
public static Block waterlily;
public static Block dirt;
public static Block farmland_0;
public static Block farmland_1;
public static Block hard_ice;
public static Block dried_sand;
public static Block mud_brick_block;
public static Block crystal;
public static Block other_slab;
public static Block double_other_slab;
public static Block mud_bricks;
public static Block mud_brick_slab;
public static Block mud_brick_stairs;
public static Block white_sandstone_stairs;
public static Block mud_brick_wall;
public static Block origin_grass_block;
public static Block dried_salt;
public static Block flesh;
public static Block nether_crystal_block;
public static Block nether_crystal;
public static Block toadstool_block;
public static Block glowshroom_block;
public static Block origin_sapling;
public static Block origin_leaves;
public static Block flowering_oak_sapling;
public static Block flowering_oak_leaves;
public static Block rainbow_birch_sapling;
public static Block rainbow_birch_leaves;
public static Block yellow_autumn_sapling;
public static Block yellow_autumn_leaves;
public static Block orange_autumn_sapling;
public static Block orange_autumn_leaves;
public static Block maple_sapling;
public static Block maple_leaves;
public static Block fir_sapling;
public static Block fir_leaves;
public static Block fir_log;
public static Block stripped_fir_log;
public static Block fir_wood;
public static Block stripped_fir_wood;
public static Block fir_planks;
public static Block fir_slab;
public static Block fir_stairs;
public static Block fir_fence;
public static Block fir_fence_gate;
public static Block fir_door;
public static Block fir_trapdoor;
public static Block fir_pressure_plate;
public static Block fir_button;
public static Block fir_sign;
public static Block fir_wall_sign;
public static Block redwood_sapling;
public static Block redwood_leaves;
public static Block redwood_log;
public static Block stripped_redwood_log;
public static Block redwood_wood;
public static Block stripped_redwood_wood;
public static Block redwood_planks;
public static Block redwood_slab;
public static Block redwood_stairs;
public static Block redwood_fence;
public static Block redwood_fence_gate;
public static Block redwood_door;
public static Block redwood_trapdoor;
public static Block redwood_pressure_plate;
public static Block redwood_button;
public static Block redwood_sign;
public static Block redwood_wall_sign;
public static Block white_cherry_sapling;
public static Block white_cherry_leaves;
public static Block pink_cherry_sapling;
public static Block pink_cherry_leaves;
public static Block cherry_log;
public static Block stripped_cherry_log;
public static Block cherry_wood;
public static Block stripped_cherry_wood;
public static Block cherry_planks;
public static Block cherry_slab;
public static Block cherry_stairs;
public static Block cherry_fence;
public static Block cherry_fence_gate;
public static Block cherry_door;
public static Block cherry_trapdoor;
public static Block cherry_pressure_plate;
public static Block cherry_button;
public static Block cherry_sign;
public static Block cherry_wall_sign;
public static Block mahogany_sapling;
public static Block mahogany_leaves;
public static Block mahogany_log;
public static Block stripped_mahogany_log;
public static Block mahogany_wood;
public static Block stripped_mahogany_wood;
public static Block mahogany_planks;
public static Block mahogany_slab;
public static Block mahogany_stairs;
public static Block mahogany_fence;
public static Block mahogany_fence_gate;
public static Block mahogany_door;
public static Block mahogany_trapdoor;
public static Block mahogany_pressure_plate;
public static Block mahogany_button;
public static Block mahogany_sign;
public static Block mahogany_wall_sign;
public static Block jacaranda_sapling;
public static Block jacaranda_leaves;
public static Block jacaranda_log;
public static Block stripped_jacaranda_log;
public static Block jacaranda_wood;
public static Block stripped_jacaranda_wood;
public static Block jacaranda_planks;
public static Block jacaranda_slab;
public static Block jacaranda_stairs;
public static Block jacaranda_fence;
public static Block jacaranda_fence_gate;
public static Block jacaranda_door;
public static Block jacaranda_trapdoor;
public static Block jacaranda_pressure_plate;
public static Block jacaranda_button;
public static Block jacaranda_sign;
public static Block jacaranda_wall_sign;
public static Block palm_sapling;
public static Block palm_leaves;
public static Block palm_log;
public static Block stripped_palm_log;
public static Block palm_wood;
public static Block stripped_palm_wood;
public static Block palm_planks;
public static Block palm_slab;
public static Block palm_stairs;
public static Block palm_fence;
public static Block palm_fence_gate;
public static Block palm_door;
public static Block palm_trapdoor;
public static Block palm_pressure_plate;
public static Block palm_button;
public static Block palm_sign;
public static Block palm_wall_sign;
public static Block willow_sapling;
public static Block willow_leaves;
public static Block willow_log;
public static Block stripped_willow_log;
public static Block willow_wood;
public static Block stripped_willow_wood;
public static Block willow_planks;
public static Block willow_slab;
public static Block willow_stairs;
public static Block willow_fence;
public static Block willow_fence_gate;
public static Block willow_door;
public static Block willow_trapdoor;
public static Block willow_pressure_plate;
public static Block willow_button;
public static Block willow_sign;
public static Block willow_wall_sign;
public static Block dead_sapling;
public static Block dead_leaves;
public static Block dead_log;
public static Block stripped_dead_log;
public static Block dead_wood;
public static Block stripped_dead_wood;
public static Block dead_planks;
public static Block dead_slab;
public static Block dead_stairs;
public static Block dead_fence;
public static Block dead_fence_gate;
public static Block dead_door;
public static Block dead_trapdoor;
public static Block dead_pressure_plate;
public static Block dead_button;
public static Block dead_sign;
public static Block dead_wall_sign;
public static Block magic_sapling;
public static Block magic_leaves;
public static Block magic_log;
public static Block stripped_magic_log;
public static Block magic_wood;
public static Block stripped_magic_wood;
public static Block magic_planks;
public static Block magic_slab;
public static Block magic_stairs;
public static Block magic_fence;
public static Block magic_fence_gate;
public static Block magic_door;
public static Block magic_trapdoor;
public static Block magic_pressure_plate;
public static Block magic_button;
public static Block magic_sign;
public static Block magic_wall_sign;
public static Block umbran_sapling;
public static Block umbran_leaves;
public static Block umbran_log;
public static Block stripped_umbran_log;
public static Block umbran_wood;
public static Block stripped_umbran_wood;
public static Block umbran_planks;
public static Block umbran_slab;
public static Block umbran_stairs;
public static Block umbran_fence;
public static Block umbran_fence_gate;
public static Block umbran_door;
public static Block umbran_trapdoor;
public static Block umbran_pressure_plate;
public static Block umbran_button;
public static Block umbran_sign;
public static Block umbran_wall_sign;
public static Block hellbark_sapling;
public static Block hellbark_leaves;
public static Block hellbark_log;
public static Block stripped_hellbark_log;
public static Block hellbark_wood;
public static Block stripped_hellbark_wood;
public static Block hellbark_planks;
public static Block hellbark_slab;
public static Block hellbark_stairs;
public static Block hellbark_fence;
public static Block hellbark_fence_gate;
public static Block hellbark_door;
public static Block hellbark_trapdoor;
public static Block hellbark_pressure_plate;
public static Block hellbark_button;
public static Block hellbark_sign;
public static Block hellbark_wall_sign;
public static Block rose;
public static Block violet;
public static Block lavender;
public static Block wildflower;
public static Block orange_cosmos;
public static Block pink_daffodil;
public static Block pink_hibiscus;
public static Block glowflower;
public static Block wilted_lily;
public static Block burning_blossom;
public static Block blue_hydrangea;
public static Block goldenrod;
public static Block ivy;
public static Block willow_vine;
public static Block plant_0;
public static Block plant_1;
public static Block double_plant;
public static Block bramble_plant;
public static Block honey_block;
public static Block terrarium;
public static Block sand;
public static Fluid sand_fluid;
public static Block honey;
public static Fluid honey_fluid;
public static Block blood;
public static Fluid blood_fluid;
public static Block poison;
public static Fluid poison_fluid;
public static Block hot_spring_water;
public static Fluid hot_spring_water_fluid;
public static Block spanish_moss;
public static Block spanish_moss_plant;
public static Block sprout;
public static Block bush;
public static Block clover;
public static Block huge_clover_petal;
public static Block dune_grass;
public static Block desert_grass;
public static Block dead_grass;
public static Block cattail;
public static Block barley;
public static Block reed;
public static Block watergrass;
public static Block mangrove_root;
public static Block dead_branch;
public static Block bramble;
public static Block toadstool;
public static Block glowshroom;
public static Block potted_origin_sapling;
public static Block potted_flowering_oak_sapling;
public static Block potted_rainbow_birch_sapling;
public static Block potted_yellow_autumn_sapling;
public static Block potted_orange_autumn_sapling;
public static Block potted_maple_sapling;
public static Block potted_fir_sapling;
public static Block potted_redwood_sapling;
public static Block potted_white_cherry_sapling;
public static Block potted_pink_cherry_sapling;
public static Block potted_mahogany_sapling;
public static Block potted_jacaranda_sapling;
public static Block potted_palm_sapling;
public static Block potted_willow_sapling;
public static Block potted_dead_sapling;
public static Block potted_magic_sapling;
public static Block potted_umbran_sapling;
public static Block potted_hellbark_sapling;
public static Block potted_rose;
public static Block potted_violet;
public static Block potted_lavender;
public static Block potted_wildflower;
public static Block potted_orange_cosmos;
public static Block potted_pink_daffodil;
public static Block potted_pink_hibiscus;
public static Block potted_glowflower;
public static Block potted_wilted_lily;
public static Block potted_burning_blossom;
public static Block potted_sprout;
public static Block potted_clover;
public static Block potted_toadstool;
public static Block potted_glowshroom;
}

View File

@ -1,46 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.block;
public class BlockQueries
{
public static IBlockPosQuery anything;
public static IBlockPosQuery nothing;
public static IBlockPosQuery hasWater;
public static IBlockPosQuery airAbove;
public static IBlockPosQuery airBelow;
public static IBlockPosQuery waterCovered;
public static IBlockPosQuery breakable;
public static IBlockPosQuery air;
public static IBlockPosQuery airOrLeaves;
public static IBlockPosQuery surfaceBlocks;
public static IBlockPosQuery groundBlocks;
public static IBlockPosQuery solid;
public static IBlockPosQuery replaceable;
public static IBlockPosQuery fertile;
public static IBlockPosQuery fertileOrNetherrack;
public static IBlockPosQuery fertileOrSand;
public static IBlockPosQuery sustainsCave;
public static IBlockPosQuery sustainsNether;
public static IBlockPosQuery endish;
public static IBlockPosQuery hellish;
public static IBlockPosQuery litFertile;
public static IBlockPosQuery litBeach;
public static IBlockPosQuery litFertileWaterside;
public static IBlockPosQuery litSand;
public static IBlockPosQuery litDry;
public static IBlockPosQuery litDryWaterside;
public static IBlockPosQuery litFertileOrDry;
public static IBlockPosQuery spectralMoss;
public static IBlockPosQuery fertileSeaBed;
public static IBlockPosQuery underwater;
public static IBlockPosQuery suitableForReed;
public static IBlockPosQuery rootsCanDigThrough;
}

View File

@ -1,17 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.block;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
// for queries on a particular block position in the world
public interface IBlockPosQuery
{
boolean matches(World world, BlockPos pos);
}

View File

@ -1,19 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.config;
public interface IBOPWorldSettings
{
boolean isEnabled(GeneratorType type);
enum GeneratorType
{
GEMS, POISON_IVY, BERRY_BUSHES, THORNS, QUICKSAND, LIQUID_POISON, HOT_SPRINGS,
NETHER_HIVES, END_FEATURES
}
}

View File

@ -1,79 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.config;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import biomesoplenty.api.block.IBlockPosQuery;
import com.google.gson.JsonElement;
import net.minecraft.block.state.IBlockState;
import net.minecraft.util.ResourceLocation;
public interface IConfigObj
{
JsonElement serializeDefaults();
void addMessage(String message);
void addMessage(String extraPrefix, String message);
List<String> flushMessages();
boolean isEmpty();
boolean has(String name);
Set<String> getKeys();
IConfigObj getObject(String name);
ArrayList<IConfigObj> getObjectArray(String name);
IConfigObj getObject(String name, boolean warnIfMissing);
ArrayList<IConfigObj> getObjectArray(String name, boolean warnIfMissing);
// Use the methods below when you want to obtain a value from a config file, if it is present, but you have a default value to use if it isn't
// No warning messages will be logged using these methods if the value is missing
Boolean getBool(String name, Boolean defaultVal);
String getString(String name, String defaultVal);
Integer getInt(String name, Integer defaultVal);
Float getFloat(String name, Float defaultVal);
IBlockState getBlockState(String name, IBlockState defaultVal);
IBlockPosQuery getBlockPosQuery(String name, IBlockPosQuery defaultVal);
ResourceLocation getResourceLocation(String name, ResourceLocation defaultVal);
<E extends Enum> E getEnum(String name, E defaultVal, Class<E> clazz);
// Use the methods below when you want to obtain a value from a config file which SHOULD be present
// If the value is missing, a warning message is logged, and null is returned
Boolean getBool(String name);
String getString(String name);
Integer getInt(String name);
Float getFloat(String name);
IBlockState getBlockState(String name);
IBlockPosQuery getBlockPosQuery(String name);
ResourceLocation getResourceLocation(String name);
<E extends Enum> E getEnum(String name, Class<E> clazz);
// Use the methods below when you want to obtain an array of values from a config file, if it is present, but you have a default value to use if it isn't
// No warning messages will be logged using these methods if the value is missing
ArrayList<Boolean> getBoolArray(String name, ArrayList<Boolean> defaultVal);
ArrayList<String> getStringArray(String name, ArrayList<String> defaultVal);
ArrayList<Integer> getIntArray(String name, ArrayList<Integer> defaultVal);
ArrayList<Float> getFloatArray(String name, ArrayList<Float> defaultVal);
ArrayList<IBlockState> getBlockStateArray(String name, ArrayList<IBlockState> defaultVal);
ArrayList<IBlockPosQuery> getBlockPosQueryArray(String name, ArrayList<IBlockPosQuery> defaultVal);
ArrayList<ResourceLocation> getResourceLocationArray(String name, ArrayList<ResourceLocation> defaultVal);
<E extends Enum> ArrayList<E> getEnumArray(String name, ArrayList<E> defaultVal, Class<E> clazz);
// Use the methods below when you want to obtain an array of values from a config file which SHOULD be present
// If the value is missing, a warning message is logged, and null is returned
ArrayList<Boolean> getBoolArray(String name);
ArrayList<String> getStringArray(String name);
ArrayList<Integer> getIntArray(String name);
ArrayList<Float> getFloatArray(String name);
ArrayList<IBlockState> getBlockStateArray(String name);
ArrayList<IBlockPosQuery> getBlockPosQueryArray(String name);
ArrayList<ResourceLocation> getResourceLocationArray(String name);
<E extends Enum> ArrayList<E> getEnumArray(String name, Class<E> clazz);
}

View File

@ -0,0 +1,16 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.entity;
import net.minecraft.entity.EntityType;
import net.minecraft.entity.item.BoatEntity;
public class BOPEntities
{
public static EntityType<? extends BoatEntity> boat_bop;
}

View File

@ -1,56 +1,91 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.enums;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.common.util.biome.BiomeUtil;
import biomesoplenty.init.ModBiomes;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import net.minecraft.util.RegistryKey;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.biome.Biomes;
import net.minecraft.world.gen.INoiseRandom;
import net.minecraftforge.common.BiomeManager;
import net.minecraftforge.common.BiomeManager.BiomeType;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Set;
import java.util.stream.Collectors;
import biomesoplenty.api.generation.BOPGenLayer;
import net.minecraft.init.Biomes;
import net.minecraft.world.biome.Biome;
import net.minecraftforge.common.BiomeManager.BiomeType;
public enum BOPClimates {
public enum BOPClimates
{
ICE_CAP (BiomeType.ICY),
TUNDRA (BiomeType.ICY),
BOREAL (BiomeType.COOL),
COLD_SWAMP (BiomeType.COOL),
WET_TEMPERATE (BiomeType.WARM),
WET_BOREAL (BiomeType.COOL),
DRY_BOREAL (BiomeType.COOL),
WET_TEMPERATE (BiomeType.COOL),
DRY_TEMPERATE (BiomeType.WARM),
COOL_TEMPERATE (BiomeType.COOL),
WARM_TEMPERATE (BiomeType.WARM),
HOT_SWAMP (BiomeType.WARM),
SUBTROPICAL (BiomeType.WARM),
TROPICAL (BiomeType.DESERT),
MEDITERANEAN (BiomeType.WARM),
MEDITERRANEAN (BiomeType.WARM),
SAVANNA (BiomeType.DESERT),
HOT_DESERT (BiomeType.DESERT),
WASTELAND (BiomeType.DESERT),
HELL (null);
WASTELAND (null),
NETHER (null);
public final BiomeType biomeType;
private int totalBiomesWeight;
private int totalIslandBiomesWeight;
private ArrayList<WeightedBiomeEntry> landBiomes = Lists.newArrayList();
private ArrayList<WeightedBiomeEntry> islandBiomes = Lists.newArrayList();
private ArrayList<WeightedBiomeEntry> landBiomes = new ArrayList<WeightedBiomeEntry>();
BOPClimates(BiomeType biomeType)
{
this.biomeType = biomeType;
}
public BOPClimates addBiome(int weight, Biome biome)
public BOPClimates addBiome(int weight, RegistryKey<Biome> biome)
{
return this.addBiome(new WeightedBiomeEntry(weight, biome));
}
public BOPClimates addBiome(WeightedBiomeEntry biomeEntry)
{
this.totalBiomesWeight += biomeEntry.weight;
this.landBiomes.add(biomeEntry);
return this;
}
public Biome getRandomBiome(BOPGenLayer layer)
public BOPClimates addIslandBiome(int weight, RegistryKey<Biome> biome)
{
int weight = layer.nextInt(this.totalBiomesWeight);
return this.addIslandBiome(new WeightedBiomeEntry(weight, biome));
}
public BOPClimates addIslandBiome(WeightedBiomeEntry biomeEntry)
{
this.totalIslandBiomesWeight += biomeEntry.weight;
this.islandBiomes.add(biomeEntry);
return this;
}
public RegistryKey<Biome> getRandomBiome(INoiseRandom context, RegistryKey<Biome> fallback)
{
if (this.totalBiomesWeight == 0)
return fallback;
int weight = context.nextRandom(this.totalBiomesWeight);
Iterator<WeightedBiomeEntry> iterator = this.landBiomes.iterator();
WeightedBiomeEntry item;
do
@ -61,53 +96,64 @@ public enum BOPClimates {
while (weight >= 0);
return item.biome;
}
public Biome getRandomOceanBiome(BOPGenLayer layer, boolean deep)
public RegistryKey<Biome> getRandomIslandBiome(INoiseRandom context, RegistryKey<Biome> fallback)
{
if (this.totalIslandBiomesWeight == 0)
return fallback;
int weight = context.nextRandom(this.totalIslandBiomesWeight);
Iterator<WeightedBiomeEntry> iterator = this.islandBiomes.iterator();
WeightedBiomeEntry item;
do
{
item = iterator.next();
weight -= item.weight;
}
while (weight >= 0);
return item.biome;
}
public RegistryKey<Biome> getRandomOceanBiome(INoiseRandom context, boolean deep)
{
return (deep ? Biomes.DEEP_OCEAN : Biomes.OCEAN);
}
static
public ImmutableList<WeightedBiomeEntry> getLandBiomes()
{
// set up vanilla biomes
BOPClimates.ICE_CAP.addBiome(10,Biomes.ICE_PLAINS);
BOPClimates.TUNDRA.addBiome(10, Biomes.COLD_TAIGA).addBiome(10, Biomes.EXTREME_HILLS);
BOPClimates.BOREAL.addBiome(5, Biomes.REDWOOD_TAIGA).addBiome(5, Biomes.EXTREME_HILLS).addBiome(20, Biomes.TAIGA);
BOPClimates.COLD_SWAMP.addBiome(5, Biomes.SWAMPLAND);
BOPClimates.WET_TEMPERATE.addBiome(20, Biomes.ROOFED_FOREST).addBiome(5, Biomes.FOREST);
BOPClimates.DRY_TEMPERATE.addBiome(5, Biomes.PLAINS);
BOPClimates.COOL_TEMPERATE.addBiome(15, Biomes.FOREST).addBiome(10, Biomes.BIRCH_FOREST);
BOPClimates.WARM_TEMPERATE.addBiome(20, Biomes.PLAINS).addBiome(5, Biomes.BIRCH_FOREST);
BOPClimates.HOT_SWAMP.addBiome(5, Biomes.SWAMPLAND);
BOPClimates.TROPICAL.addBiome(15, Biomes.JUNGLE);
BOPClimates.MEDITERANEAN.addBiome(5, Biomes.PLAINS);
BOPClimates.SAVANNA.addBiome(20, Biomes.SAVANNA);
BOPClimates.HOT_DESERT.addBiome(30, Biomes.DESERT).addBiome(15, Biomes.MESA_CLEAR_ROCK);
BOPClimates.WASTELAND.addBiome(1, Biomes.DESERT);
BOPClimates.HELL.addBiome(30, Biomes.HELL);
return this.landBiomes.isEmpty() ? ImmutableList.of(this.getDefaultWeightedBiomeEntry()) : ImmutableList.copyOf(this.landBiomes);
}
public ImmutableList<WeightedBiomeEntry> getIslandBiomes()
{
return this.islandBiomes.isEmpty() ? ImmutableList.of(this.getDefaultWeightedBiomeEntry()) : ImmutableList.copyOf(this.islandBiomes);
}
private WeightedBiomeEntry getDefaultWeightedBiomeEntry()
{
return new WeightedBiomeEntry(100, Biomes.OCEAN);
}
private static BOPClimates[] values = BOPClimates.values();
public static BOPClimates lookup(int i) {return values[i];}
// map temperature and rainfall to climates
// temperature values from 0 (cold) to 8 (hot) and rainfall values from 0 (wet) to 11 (dry), index is (temperatureValue * 12) + rainfallValue
// we will contrive to make any combination equally likely, so the overall rarity of each climate is in proportion to the number of times it appears in the array
private static final BOPClimates[] climateMapping = new BOPClimates[] {
// 0 1 2 3 4 5 6 7 8 9 10 11
TUNDRA, TUNDRA, TUNDRA, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, // 0
BOREAL, BOREAL, BOREAL, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, // 1
COLD_SWAMP, COLD_SWAMP, COLD_SWAMP, BOREAL, BOREAL, BOREAL, BOREAL, BOREAL, BOREAL, BOREAL, BOREAL, BOREAL, // 2
COLD_SWAMP, COLD_SWAMP, COLD_SWAMP, WET_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, // 3
COLD_SWAMP, WET_TEMPERATE, WET_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, // 4
WET_TEMPERATE, WET_TEMPERATE, WET_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, DRY_TEMPERATE, SAVANNA, SAVANNA, // 5
HOT_SWAMP, HOT_SWAMP, HOT_SWAMP, WET_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, MEDITERANEAN, MEDITERANEAN, SAVANNA, HOT_DESERT, HOT_DESERT, // 6
TROPICAL, TROPICAL, HOT_SWAMP, HOT_SWAMP, WET_TEMPERATE, WARM_TEMPERATE, MEDITERANEAN, MEDITERANEAN, SAVANNA, HOT_DESERT, HOT_DESERT, WASTELAND, // 7
TROPICAL, TROPICAL, TROPICAL, HOT_SWAMP, HOT_SWAMP, MEDITERANEAN, MEDITERANEAN, SAVANNA, HOT_DESERT, HOT_DESERT, WASTELAND, WASTELAND // 8
private static final BOPClimates[] climateMapping = new BOPClimates[]
{
TUNDRA, TUNDRA, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, ICE_CAP, TUNDRA, TUNDRA,
WET_BOREAL, WET_BOREAL, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, TUNDRA, DRY_BOREAL, DRY_BOREAL,
WET_BOREAL, WET_BOREAL, WET_BOREAL, WET_BOREAL, WET_BOREAL, WET_BOREAL, DRY_BOREAL, DRY_BOREAL, DRY_BOREAL, DRY_BOREAL, DRY_BOREAL, DRY_BOREAL,
WET_TEMPERATE, WET_TEMPERATE, WET_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE,
WET_TEMPERATE, WET_TEMPERATE, WET_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, COOL_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE, DRY_TEMPERATE,
SUBTROPICAL, SUBTROPICAL, WET_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, DRY_TEMPERATE, SAVANNA, SAVANNA,
SUBTROPICAL, SUBTROPICAL, SUBTROPICAL, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, WARM_TEMPERATE, SAVANNA, SAVANNA, SAVANNA,
TROPICAL, TROPICAL, SUBTROPICAL, SUBTROPICAL, MEDITERRANEAN, MEDITERRANEAN, MEDITERRANEAN, MEDITERRANEAN, SAVANNA, SAVANNA, HOT_DESERT, HOT_DESERT,
TROPICAL, TROPICAL, SUBTROPICAL, SUBTROPICAL, MEDITERRANEAN, MEDITERRANEAN, MEDITERRANEAN, MEDITERRANEAN, SAVANNA, SAVANNA, HOT_DESERT, HOT_DESERT
};
public static int[] getClimateMappingInts()
{
// 9 temperature values, 12 rainfall values, 12 * 9 = 108
@ -118,19 +164,38 @@ public enum BOPClimates {
}
return out;
}
public static ImmutableSet<RegistryKey<Biome>> getOverworldBiomes()
{
Set<RegistryKey<Biome>> set = Sets.newHashSet();
for (BOPClimates climate : BOPClimates.values())
{
if (climate == BOPClimates.NETHER)
{
continue;
}
set.addAll(climate.getLandBiomes().stream().map(weightedBiomeEntry -> weightedBiomeEntry.biome).collect(Collectors.toSet()));
set.addAll(climate.getIslandBiomes().stream().map(weightedBiomeEntry -> weightedBiomeEntry.biome).collect(Collectors.toSet()));
}
ModBiomes.subBiomes.values().forEach(weightedSubBiome -> set.add(weightedSubBiome.biome));
return ImmutableSet.copyOf(set);
}
public static class WeightedBiomeEntry
{
public final int weight;
public final Biome biome;
public WeightedBiomeEntry(int weight, Biome biome)
public final RegistryKey<Biome> biome;
public WeightedBiomeEntry(int weight, RegistryKey<Biome> biome)
{
this.weight = weight;
this.biome = biome;
}
}
// for debugging purposes
public static void printWeights()
{
@ -138,7 +203,7 @@ public enum BOPClimates {
{
for (WeightedBiomeEntry entry : climate.landBiomes)
{
System.out.println(climate.name()+" "+entry.biome.getBiomeName()+" "+entry.weight);
System.out.println(climate.name()+" "+entry.biome.location()+" "+entry.weight);
}
}
}

View File

@ -1,27 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.enums;
import net.minecraft.util.IStringSerializable;
public enum BOPFlowers implements IStringSerializable, IPagedVariants
{
CLOVER, SWAMPFLOWER, DEATHBLOOM, GLOWFLOWER, BLUE_HYDRANGEA, ORANGE_COSMOS, PINK_DAFFODIL, WILDFLOWER, VIOLET, WHITE_ANEMONE, ENDERLOTUS, BROMELIAD, WILTED_LILY, PINK_HIBISCUS, LILY_OF_THE_VALLEY, BURNING_BLOSSOM, LAVENDER, GOLDENROD, BLUEBELLS, MINERS_DELIGHT, ICY_IRIS, ROSE;
@Override
public String getName() {
return this.name().toLowerCase();
}
@Override
public String toString()
{
return this.getName();
}
}

View File

@ -1,26 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.enums;
import net.minecraft.util.IStringSerializable;
public enum BOPGems implements IStringSerializable
{
AMETHYST, RUBY, PERIDOT, TOPAZ, TANZANITE, MALACHITE, SAPPHIRE, AMBER;
@Override
public String getName()
{
return this.name().toLowerCase();
}
@Override
public String toString()
{
return this.getName();
}
}

View File

@ -1,27 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.enums;
import net.minecraft.util.IStringSerializable;
public enum BOPPlants implements IStringSerializable, IPagedVariants
{
SHORTGRASS, MEDIUMGRASS, BUSH, SPROUT, POISONIVY, BERRYBUSH, SHRUB, WHEATGRASS, DAMPGRASS, KORU, CLOVERPATCH, LEAFPILE, DEADLEAFPILE, DEADGRASS, DESERTGRASS, DESERTSPROUTS, DUNEGRASS, SPECTRALFERN, THORN, WILDRICE, CATTAIL, RIVERCANE, TINYCACTUS, DEVILWEED, REED, ROOT, RAFFLESIA, BARLEY;
@Override
public String getName() {
return this.name().toLowerCase();
}
@Override
public String toString()
{
return this.getName();
}
}

View File

@ -1,46 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.enums;
import com.google.common.base.Predicate;
import net.minecraft.util.IStringSerializable;
public enum BOPTrees implements IStringSerializable, IPagedVariants
{
YELLOW_AUTUMN, ORANGE_AUTUMN, BAMBOO, MAGIC, UMBRAN, DEAD, FIR, ETHEREAL, ORIGIN, PINK_CHERRY, WHITE_CHERRY, MAPLE, HELLBARK, FLOWERING, JACARANDA, SACRED_OAK, MANGROVE, PALM, REDWOOD, WILLOW, PINE, MAHOGANY, EBONY, EUCALYPTUS, RED_BIG_FLOWER, YELLOW_BIG_FLOWER;
@Override
public String getName() {
return this.name().toLowerCase();
}
@Override
public String toString()
{
return this.getName();
}
public boolean hasSapling()
{
switch(this)
{
case YELLOW_BIG_FLOWER: case RED_BIG_FLOWER:
return false;
default:
return true;
}
}
public static Predicate withSaplings = new Predicate<BOPTrees>()
{
@Override
public boolean apply(BOPTrees tree) {return tree.hasSapling();}
};
}

View File

@ -1,53 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.enums;
import com.google.common.base.Predicate;
import net.minecraft.util.IStringSerializable;
public enum BOPWoods implements IStringSerializable, IPagedVariants
{
SACRED_OAK, CHERRY, UMBRAN, FIR, ETHEREAL, MAGIC, MANGROVE, PALM, REDWOOD, WILLOW, PINE, HELLBARK, JACARANDA, MAHOGANY, EBONY, EUCALYPTUS, GIANT_FLOWER, DEAD;
@Override
public String getName() {
return this.name().toLowerCase();
}
@Override
public String toString()
{
return this.getName();
}
public boolean hasPlanks()
{
switch (this) {
case GIANT_FLOWER: case DEAD:
return false;
default:
return true;
}
}
public boolean canMakeCharcoal()
{
switch (this) {
case GIANT_FLOWER:
return false;
default:
return true;
}
}
public static Predicate withPlanks = new Predicate<BOPWoods>()
{
@Override
public boolean apply(BOPWoods wood) {return wood.hasPlanks();}
};
}

View File

@ -1,5 +0,0 @@
package biomesoplenty.api.enums;
public interface IPagedVariants {
}

View File

@ -1,24 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import net.minecraft.world.gen.layer.GenLayer;
public abstract class BOPGenLayer extends GenLayer
{
public BOPGenLayer(long seed) {
super(seed);
}
// make nextInt public
@Override
public int nextInt(int a)
{
return super.nextInt(a);
}
}

View File

@ -1,98 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import java.util.Random;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenerator;
public abstract class BOPGeneratorBase extends WorldGenerator implements IGenerator
{
protected final String identifier;
protected String name;
protected GeneratorStage stage;
protected float amountPerChunk;
protected BOPGeneratorBase(float amountPerChunk)
{
this.identifier = Generators.registry.getIdentifier(this.getClass());
if (this.identifier == null)
{
throw new RuntimeException("The identifier for " + this.getClass().getCanonicalName() + " cannot be null!");
}
this.amountPerChunk = amountPerChunk;
}
protected static abstract class InnerBuilder<T extends InnerBuilder<T, G>, G extends BOPGeneratorBase>
{
protected T self() {return (T)this;}
protected float amountPerChunk;
public T amountPerChunk(float amountPerChunk) {this.amountPerChunk = amountPerChunk; return this.self();}
public abstract G create();
}
@Override
public void setName(String name)
{
this.name = name;
}
@Override
public void setStage(GeneratorStage stage)
{
this.stage = stage;
}
@Override
public String getName()
{
return this.name;
}
@Override
public GeneratorStage getStage()
{
return this.stage;
}
@Override
public final String getIdentifier()
{
return this.identifier;
}
public abstract BlockPos getScatterY(World world, Random random, int x, int z);
public int getAmountToScatter(Random random)
{
int amount = MathHelper.floor(this.amountPerChunk);
float remainder = this.amountPerChunk - amount;
if (random.nextFloat() < remainder) {amount++;}
return amount;
}
@Override
public void scatter(World world, Random random, BlockPos pos)
{
int amount = this.getAmountToScatter(random);
for (int i = 0; i < amount; i++)
{
int x = pos.getX() + random.nextInt(16) + 8;
int z = pos.getZ() + random.nextInt(16) + 8;
generate(world, random, this.getScatterY(world, random, x, z));
}
}
}

View File

@ -1,110 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import java.util.EnumMap;
import com.google.common.collect.Maps;
import com.google.gson.annotations.SerializedName;
import net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate;
public enum GeneratorStage
{
@SerializedName("pre")
PRE(null),
@SerializedName("big_shroom")
BIG_SHROOM(Decorate.EventType.BIG_SHROOM),
@SerializedName("cactus")
CACTUS(Decorate.EventType.CACTUS),
@SerializedName("clay")
CLAY(Decorate.EventType.CLAY),
@SerializedName("dead_bush")
DEAD_BUSH(Decorate.EventType.DEAD_BUSH),
@SerializedName("desert_well")
DESERT_WELL(Decorate.EventType.DESERT_WELL),
@SerializedName("lilypad")
LILYPAD(Decorate.EventType.LILYPAD),
@SerializedName("flowers")
FLOWERS(Decorate.EventType.FLOWERS),
@SerializedName("fossil")
FOSSIL(Decorate.EventType.FOSSIL),
@SerializedName("grass")
GRASS(Decorate.EventType.GRASS),
@SerializedName("ice")
ICE(Decorate.EventType.ICE),
@SerializedName("lake_water")
LAKE_WATER(Decorate.EventType.LAKE_WATER),
@SerializedName("lake_lava")
LAKE_LAVA(Decorate.EventType.LAKE_LAVA),
@SerializedName("pumpkin")
PUMPKIN(Decorate.EventType.PUMPKIN),
@SerializedName("reed")
REED(Decorate.EventType.REED),
@SerializedName("rock")
ROCK(Decorate.EventType.ROCK),
@SerializedName("sand")
SAND(Decorate.EventType.SAND),
@SerializedName("sand_pass_2")
SAND_PASS2(Decorate.EventType.SAND_PASS2),
@SerializedName("shroom")
SHROOM(Decorate.EventType.SHROOM),
@SerializedName("tree")
TREE(Decorate.EventType.TREE),
@SerializedName("post")
POST(null),
@SerializedName("parent")
PARENT(null),
@SerializedName("ore_pre")
ORE_PRE(null),
@SerializedName("ore_post")
ORE_POST(null);
private Decorate.EventType decorateType;
GeneratorStage(Decorate.EventType decorateType)
{
this.decorateType = decorateType;
}
public Decorate.EventType getDecorateType()
{
return this.decorateType;
}
private static final EnumMap<Decorate.EventType, GeneratorStage> decorateTypeMapper = Maps.newEnumMap(Decorate.EventType.class);
static
{
decorateTypeMapper.put(Decorate.EventType.BIG_SHROOM, BIG_SHROOM);
decorateTypeMapper.put(Decorate.EventType.CACTUS, CACTUS);
decorateTypeMapper.put(Decorate.EventType.CLAY, CLAY);
decorateTypeMapper.put(Decorate.EventType.DEAD_BUSH, DEAD_BUSH);
decorateTypeMapper.put(Decorate.EventType.DESERT_WELL, DESERT_WELL);
decorateTypeMapper.put(Decorate.EventType.LILYPAD, LILYPAD);
decorateTypeMapper.put(Decorate.EventType.FLOWERS, FLOWERS);
decorateTypeMapper.put(Decorate.EventType.FOSSIL, FOSSIL);
decorateTypeMapper.put(Decorate.EventType.GRASS, GRASS);
decorateTypeMapper.put(Decorate.EventType.ICE, ICE);
decorateTypeMapper.put(Decorate.EventType.LAKE_WATER, LAKE_WATER);
decorateTypeMapper.put(Decorate.EventType.LAKE_LAVA, LAKE_LAVA);
decorateTypeMapper.put(Decorate.EventType.PUMPKIN, PUMPKIN);
decorateTypeMapper.put(Decorate.EventType.REED, REED);
decorateTypeMapper.put(Decorate.EventType.ROCK, ROCK);
decorateTypeMapper.put(Decorate.EventType.SAND, SAND);
decorateTypeMapper.put(Decorate.EventType.SAND_PASS2, SAND_PASS2);
decorateTypeMapper.put(Decorate.EventType.SHROOM, SHROOM);
decorateTypeMapper.put(Decorate.EventType.TREE, TREE);
}
public static GeneratorStage mapDecorateType(Decorate.EventType decorateType)
{
//Somewhat of a hack, requires the ordering of our enum to be the same as the decorate event
return decorateType != Decorate.EventType.CUSTOM ? decorateTypeMapper.get(decorateType) : null;
}
}

View File

@ -1,18 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import net.minecraft.world.gen.layer.GenLayer;
public class Generators
{
public static IGeneratorRegistry registry;
public static GenLayer biomeGenLayer;
public static GenLayer biomeIndexLayer;
}

View File

@ -1,21 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import com.google.common.collect.ImmutableCollection;
import biomesoplenty.api.config.IConfigObj;
public interface IGenerationManager
{
void addGenerator(String name, GeneratorStage stage, IGenerator generator);
ImmutableCollection<IGenerator> getGeneratorsForStage(GeneratorStage stage);
void removeGenerator(String name);
IGenerator getGenerator(String name);
void configure(IConfigObj conf);
}

View File

@ -1,40 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import java.util.Random;
import biomesoplenty.api.config.IConfigObj;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
public interface IGenerator
{
void scatter(World world, Random random, BlockPos pos);
boolean generate(World world, Random random, BlockPos pos);
void setStage(GeneratorStage stage);
void setName(String name);
/**
* A unique name used to classify the purpose of a generator. For example, emeralds and ruby use the
* same generator (and thus, have the same identifier) but have differing names.
*/
String getName();
/**The identifier for this generator should be consistent across all instances of the same type*/
String getIdentifier();
GeneratorStage getStage();
interface IGeneratorBuilder<T extends IGenerator>
{
T create();
}
void configure(IConfigObj conf);
}

View File

@ -1,20 +0,0 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.generation;
import biomesoplenty.api.config.IConfigObj;
public interface IGeneratorRegistry
{
<T extends IGenerator> void registerGenerator(String identifier, Class<T> generatorClass, IGenerator.IGeneratorBuilder<T> builder);
String getIdentifier(Class<? extends IGenerator> generatorClass);
Class<? extends IGenerator> getGeneratorClass(String identifier);
IGenerator.IGeneratorBuilder<?> getGeneratorBuilder(String identifier);
boolean generatorExists(String identifier);
IGenerator createGenerator(IConfigObj conf);
}

View File

@ -1,88 +1,32 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.item;
import net.minecraft.item.Item;
public class BOPItems
public class BOPItems
{
public static Item berries;
public static Item shroompowder;
public static Item peach;
public static Item earth;
public static Item persimmon;
public static Item filled_honeycomb;
public static Item pear;
public static Item ricebowl;
public static Item fleshchunk;
public static Item mudball;
public static Item crystal_shard;
public static Item terrestrial_artifact;
public static Item honeycomb;
public static Item gem;
public static Item ash;
public static Item mud_brick;
public static Item blue_dye;
public static Item brown_dye;
public static Item green_dye;
public static Item white_dye;
public static Item black_dye;
public static Item other_slab;
public static Item boat_sacred_oak;
public static Item boat_cherry;
public static Item boat_umbran;
public static Item boat_fir;
public static Item boat_ethereal;
public static Item boat_magic;
public static Item boat_mangrove;
public static Item boat_palm;
public static Item boat_redwood;
public static Item boat_willow;
public static Item boat_pine;
public static Item boat_hellbark;
public static Item boat_jacaranda;
public static Item boat_mahogany;
public static Item boat_ebony;
public static Item boat_eucalyptus;
public static Item sacred_oak_door;
public static Item cherry_door;
public static Item umbran_door;
public static Item fir_door;
public static Item ethereal_door;
public static Item magic_door;
public static Item mangrove_door;
public static Item palm_door;
public static Item redwood_door;
public static Item willow_door;
public static Item pine_door;
public static Item hellbark_door;
public static Item jacaranda_door;
public static Item mahogany_door;
public static Item ebony_door;
public static Item eucalyptus_door;
public static Item wood_slab_0;
public static Item wood_slab_1;
public static Item biome_finder;
public static Item biome_essence;
public static Item jar_empty;
public static Item jar_filled;
public static Item record_wanderer;
public static Item bop_icon;
// TODO: public static Item ancientStaff;
// TODO: public static Item bop_bucket;
public static Item mud_ball;
public static Item mud_brick;
public static Item fir_boat;
public static Item redwood_boat;
public static Item cherry_boat;
public static Item mahogany_boat;
public static Item jacaranda_boat;
public static Item palm_boat;
public static Item willow_boat;
public static Item dead_boat;
public static Item magic_boat;
public static Item umbran_boat;
public static Item hellbark_boat;
public static Item music_disc_wanderer;
}

View File

@ -1,6 +1,13 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.particle;
public enum BOPParticleTypes
{
MUD, PLAYER_TRAIL, CURSE
}
MUD
}

View File

@ -1,16 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.potion;
import net.minecraft.potion.Potion;
public class BOPPotions
{
public static Potion curse;
}

View File

@ -1,17 +1,15 @@
/*******************************************************************************
* Copyright 2016, the Biomes O' Plenty Team
*
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.api.sound;
import net.minecraft.util.SoundEvent;
public class BOPSounds
public class BOPSounds
{
public static SoundEvent wasp_ambient;
public static SoundEvent wasp_hurt;
public static SoundEvent records_wanderer;
public static SoundEvent music_disc_wanderer;
}

View File

@ -0,0 +1,141 @@
/**Copied from Twilight Forest and modified with permission**/
package biomesoplenty.client;
import biomesoplenty.core.BiomesOPlenty;
import com.google.common.base.Joiner;
import net.minecraft.resources.ResourcePack;
import net.minecraft.resources.ResourcePackFileNotFoundException;
import net.minecraft.resources.ResourcePackType;
import net.minecraft.resources.data.IMetadataSectionSerializer;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.fml.loading.moddiscovery.ModFile;
import javax.annotation.Nullable;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
@OnlyIn(Dist.CLIENT)
public class BOPClassicPack extends ResourcePack
{
private final ModFile modFile;
private static final String subDir = "classic/";
public BOPClassicPack(ModFile modFile)
{
super(modFile.getFilePath().toFile());
this.modFile = modFile;
}
@Override
public Set<String> getNamespaces(ResourcePackType type)
{
try
{
Path root = modFile.getLocator().findPath(modFile, subDir + type.getDirectory()).toAbsolutePath();
return Files.walk(root,1).map(path -> root.relativize(path.toAbsolutePath())).filter(path -> path.getNameCount() > 0).map(p->p.toString().replaceAll("/$","")).filter(s -> !s.isEmpty()).collect(Collectors.toSet());
}
catch (Throwable t)
{
BiomesOPlenty.logger.error("BOPClassicPack failed to collect resource namespaces!", t);
return Collections.emptySet();
}
}
@Override
protected InputStream getResource(String location) throws IOException
{
final Path path = modFile.getLocator().findPath(modFile, subDir + location);
if (!Files.exists(path))
{
BiomesOPlenty.logger.error("File does not exist!");
throw new ResourcePackFileNotFoundException(path.toFile(), location);
}
return Files.newInputStream(path, StandardOpenOption.READ);
}
@Override
protected boolean hasResource(String resourcePath)
{
return Files.exists(modFile.getLocator().findPath(modFile, subDir + resourcePath));
}
@Override
public Collection<ResourceLocation> getResources(ResourcePackType type, String namespaceIn, String pathIn, int maxDepthIn, Predicate<String> filterIn)
{
try
{
Path root = modFile.getLocator().findPath(modFile, subDir + type.getDirectory()).toAbsolutePath();
Path inputPath = root.getFileSystem().getPath(pathIn);
return Files.walk(root).map(path -> root.relativize(path.toAbsolutePath())).filter(path -> path.getNameCount() > 1 && path.getNameCount() - 1 <= maxDepthIn).filter(path -> !path.toString().endsWith(".mcmeta")).filter(path -> path.subpath(1, path.getNameCount()).startsWith(inputPath)).filter(path -> filterIn.test(path.getFileName().toString())).map(path -> new ResourceLocation(path.getName(0).toString(), Joiner.on('/').join(path.subpath(1, Math.min(maxDepthIn, path.getNameCount()))))).collect(Collectors.toList());
}
catch (IOException e)
{
return Collections.emptyList();
}
}
@Override
public void close() { }
@Override
public String getName()
{
return "BOP Programmer Art";
}
@Nullable
@Override
public <T> T getMetadataSection(IMetadataSectionSerializer<T> serializer) throws IOException
{
InputStream inputStream = getResource("pack.mcmeta");
Throwable throwable = null;
T resourceMetaData;
try
{
resourceMetaData = getMetadataFromStream(serializer, inputStream);
}
catch (Throwable t)
{
throwable = t;
throw t;
}
finally
{
if (inputStream != null)
{
if (throwable != null)
{
try
{
inputStream.close();
}
catch (Throwable t)
{
throwable.addSuppressed(t);
}
}
else
{
inputStream.close();
}
}
}
return resourceMetaData;
}
}

View File

@ -1,641 +0,0 @@
package biomesoplenty.client.gui;
import java.io.IOException;
import com.google.common.base.Predicate;
import com.google.common.primitives.Floats;
import biomesoplenty.common.world.BOPWorldSettings;
import biomesoplenty.common.world.BOPWorldSettings.BiomeSize;
import biomesoplenty.common.world.BOPWorldSettings.LandMassScheme;
import biomesoplenty.common.world.BOPWorldSettings.RainfallVariationScheme;
import biomesoplenty.common.world.BOPWorldSettings.TemperatureVariationScheme;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiCreateWorld;
import net.minecraft.client.gui.GuiListButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.GuiSlider;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.client.resources.I18n;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class GuiBOPConfigureWorld extends GuiScreen implements GuiSlider.FormatHelper, GuiBOPPageList.GuiResponder
{
private GuiCreateWorld parentScreen;
protected String screenTitle = "Customize World Settings";
protected String pageInfo = "Page 1 of 3";
protected String page0Title = "Basic Settings";
protected String[] pageNames;
private GuiBOPPageManager pageManager;
//Navigation buttons, required on all pages
private GuiButton doneButton;
private GuiButton defaultsButton;
private GuiButton prevButton;
private GuiButton nextButton;
private GuiButton yesButton;
private GuiButton noButton;
private int modalAction = 0;
private boolean field_175340_C = false;
private Predicate validFloatPredicate = new Predicate()
{
public boolean tryParseValidFloat(String p_178956_1_)
{
Float f = Floats.tryParse(p_178956_1_);
return p_178956_1_.length() == 0 || f != null && Floats.isFinite(f.floatValue()) && f.floatValue() >= 0.0F;
}
@Override
public boolean apply(Object p_apply_1_)
{
return this.tryParseValidFloat((String)p_apply_1_);
}
};
private BOPWorldSettings settings;
public GuiBOPConfigureWorld(GuiScreen parentScreen, String settingsStringIn)
{
this.parentScreen = (GuiCreateWorld)parentScreen;
if (settingsStringIn.isEmpty())
{
this.settings = new BOPWorldSettings();
} else {
this.settings = new BOPWorldSettings(settingsStringIn);
}
}
private enum Actions
{
PREVIOUS (301),
NEXT (302),
DEFAULTS (303),
DONE (304),
YES (305),
NO (306);
private int id;
Actions(int id)
{
this.id = id;
}
public int getId()
{
return this.id;
}
public static Actions fromId(int id)
{
for (Actions action : Actions.values())
{
if (action.id == id)
{
return action;
}
}
return null;
}
}
@Override
public void initGui()
{
this.screenTitle = I18n.format("options.customizeTitle");
this.buttonList.clear();
this.buttonList.add(this.prevButton = new GuiButton(Actions.PREVIOUS.getId(), 20, 5, 80, 20, I18n.format("createWorld.customize.custom.prev")));
this.buttonList.add(this.nextButton = new GuiButton(Actions.NEXT.getId(), this.width - 100, 5, 80, 20, I18n.format("createWorld.customize.custom.next")));
this.buttonList.add(this.defaultsButton = new GuiButton(Actions.DEFAULTS.getId(), this.width / 2 - 187, this.height - 27, 90, 20, I18n.format("createWorld.customize.custom.defaults")));
this.buttonList.add(this.doneButton = new GuiButton(Actions.DONE.getId(), this.width / 2 + 98, this.height - 27, 90, 20, I18n.format("gui.done")));
this.yesButton = new GuiButton(Actions.YES.getId(), this.width / 2 - 55, 160, 50, 20, I18n.format("gui.yes"));
this.yesButton.visible = false;
this.buttonList.add(this.yesButton);
this.noButton = new GuiButton(Actions.NO.getId(), this.width / 2 + 5, 160, 50, 20, I18n.format("gui.no"));
this.noButton.visible = false;
this.buttonList.add(this.noButton);
this.setupPages();
}
@Override
public void handleMouseInput() throws IOException
{
super.handleMouseInput();
this.pageManager.getActivePage().handleMouseInput();
}
@Override
protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException
{
super.mouseClicked(mouseX, mouseY, mouseButton);
if (this.modalAction == 0 && !this.field_175340_C)
{
this.pageManager.getActivePage().mouseClicked(mouseX, mouseY, mouseButton);
}
}
@Override
protected void mouseReleased(int mouseX, int mouseY, int state)
{
super.mouseReleased(mouseX, mouseY, state);
if (this.field_175340_C)
{
this.field_175340_C = false;
}
else if (this.modalAction == 0)
{
this.pageManager.getActivePage().mouseReleased(mouseX, mouseY, state);
}
}
private enum GuiEntries
{
TEMP_SCHEME (101),
GENERATE_BOP_GEMS (102),
AMPLITUDE (104),
BIOME_SIZE (105),
LAND_SCHEME (106),
RAIN_SCHEME (107),
GENERATE_POISON_IVY (117),
GENERATE_BERRY_BUSHES (119),
GENERATE_THORNS (120),
GENERATE_QUICKSAND (121),
GENERATE_LIQUID_POISON (122),
GENERATE_HOT_SPRINGS (123),
GENERATE_NETHER_HIVES (124),
GENERATE_END_FEATURES (126),
MAIN_NOISE_SCALE_X (127),
MAIN_NOISE_SCALE_Y (128),
MAIN_NOISE_SCALE_Z (129),
COORDINATE_SCALE (130),
HEIGHT_SCALE (131),
UPPER_LIMIT_SCALE (132),
LOWER_LIMIT_SCALE (133);
private int id;
GuiEntries(int id)
{
this.id = id;
}
public int getId()
{
return this.id;
}
public static GuiEntries fromId(int id)
{
for (GuiEntries entry : GuiEntries.values())
{
if (entry.id == id)
{
return entry;
}
}
return null;
}
}
private void setupPages()
{
this.pageNames = new String[3];
this.pageNames[0] = "World Settings";
GuiBOPPageList.GuiFieldEntry[] page0Fields = new GuiBOPPageList.GuiFieldEntry[] {
new GuiBOPPageList.GuiEnumButtonEntry<BiomeSize>(GuiEntries.BIOME_SIZE.getId(), "Biome Size: %s", true, this.settings.biomeSize),
new GuiBOPPageList.GuiEnumButtonEntry<LandMassScheme>(GuiEntries.LAND_SCHEME.getId(), "Land Mass: %s", true, this.settings.landScheme),
new GuiBOPPageList.GuiEnumButtonEntry<TemperatureVariationScheme>(GuiEntries.TEMP_SCHEME.getId(), "Temperature: %s", true, this.settings.tempScheme),
new GuiBOPPageList.GuiEnumButtonEntry<RainfallVariationScheme>(GuiEntries.RAIN_SCHEME.getId(), "Rainfall: %s", true, this.settings.rainScheme),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.AMPLITUDE.getId(), "Amplitude", true, this, 0.2F, 3.0F, this.settings.amplitude),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.MAIN_NOISE_SCALE_X.getId(), "Main Noise Scale X", true, this, 1.0F, 5000.0F, this.settings.mainNoiseScaleX),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.MAIN_NOISE_SCALE_Y.getId(), "Main Noise Scale Y", true, this, 1.0F, 5000.0F, this.settings.mainNoiseScaleY),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.MAIN_NOISE_SCALE_Z.getId(), "Main Noise Scale Z", true, this, 1.0F, 5000.0F, this.settings.mainNoiseScaleZ),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.COORDINATE_SCALE.getId(), "Coordinate Scale", true, this, 1.0F, 6000.0F, this.settings.coordinateScale),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.HEIGHT_SCALE.getId(), "Height Scale", true, this, 1.0F, 6000.0F, this.settings.heightScale),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.UPPER_LIMIT_SCALE.getId(), "Upper Limit Scale", true, this, 1.0F, 5000.0F, this.settings.upperLimitScale),
new GuiBOPPageList.GuiSlideEntry(GuiEntries.LOWER_LIMIT_SCALE.getId(), "Lower Limit Scale", true, this, 1.0F, 5000.0F, this.settings.lowerLimitScale),
};
this.pageNames[1] = "Biome Settings";
GuiBOPPageList.GuiFieldEntry[] page1Fields = new GuiBOPPageList.GuiFieldEntry[] {
};
this.pageNames[2] = "Feature Generation Settings";
GuiBOPPageList.GuiFieldEntry[] page2Fields = new GuiBOPPageList.GuiFieldEntry[] {
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_BOP_GEMS.getId(), "BOP Gems", true, this.settings.generateBopGems),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_POISON_IVY.getId(), "Poison Ivy", true, this.settings.generatePoisonIvy),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_BERRY_BUSHES.getId(), "Berry Bushes", true, this.settings.generateBerryBushes),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_THORNS.getId(), "Thorns", true, this.settings.generateThorns),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_QUICKSAND.getId(), "Quicksand", true, this.settings.generateQuicksand),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_LIQUID_POISON.getId(), "Liquid Poison Pools", true, this.settings.generateLiquidPoison),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_HOT_SPRINGS.getId(), "Hot Spring Pools", true, this.settings.generateHotSprings),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_NETHER_HIVES.getId(), "Nether Hives", true, this.settings.generateNetherHives),
new GuiBOPPageList.GuiButtonEntry(GuiEntries.GENERATE_END_FEATURES.getId(), "End Features", true, this.settings.generateEndFeatures)
};
this.pageManager = new GuiBOPPageManager(createTableForFields(page0Fields, page1Fields, page2Fields));
this.pageManager.setup();
this.showNewPage();
}
private GuiBOPPageTable[] createTableForFields(GuiBOPPageList.GuiFieldEntry[]... fieldGroup)
{
GuiBOPPageTable[] output = new GuiBOPPageTable[fieldGroup.length];
for (int i = 0; i < fieldGroup.length; i++)
{
GuiBOPPageList.GuiFieldEntry[] fields = fieldGroup[i];
output[i] = new GuiBOPPageTable(this.width, this.height, 32, this.height - 32, 25, i, this, fields);
}
return output;
}
public String serialize()
{
return this.settings.toString().replace("\n", "");
}
@Override
public String getText(int id, String name, float value)
{
return name + ": " + this.stringFormatFloat(id, value);
}
private String stringFormatFloat(int fieldId, float value)
{
GuiEntries entry = GuiEntries.fromId(fieldId);
if (entry == null) {return "";}
switch (entry)
{
case AMPLITUDE:
case MAIN_NOISE_SCALE_X:
case MAIN_NOISE_SCALE_Y:
case MAIN_NOISE_SCALE_Z:
case COORDINATE_SCALE:
case HEIGHT_SCALE:
case UPPER_LIMIT_SCALE:
case LOWER_LIMIT_SCALE:
return String.format("%5.3f", Float.valueOf(value));
default:
return "";
}
}
@Override
public void handleEnumSelection(int fieldId, int ordinal)
{
GuiEntries entry = GuiEntries.fromId(fieldId);
if (entry == null) {return;}
switch (entry)
{
case LAND_SCHEME:
LandMassScheme[] land_values = LandMassScheme.values();
this.settings.landScheme = land_values[ordinal % land_values.length];
break;
case TEMP_SCHEME:
TemperatureVariationScheme[] temp_values = TemperatureVariationScheme.values();
this.settings.tempScheme = temp_values[ordinal % temp_values.length];
break;
case RAIN_SCHEME:
RainfallVariationScheme[] rain_values = RainfallVariationScheme.values();
this.settings.rainScheme = rain_values[ordinal % rain_values.length];
break;
case BIOME_SIZE:
BiomeSize[] size_values = BiomeSize.values();
this.settings.biomeSize = size_values[ordinal % size_values.length];
break;
default:
break;
}
System.out.println("settings currently: "+this.settings.toJson());
}
@Override
public void handleBooleanSelection(int fieldId, boolean value)
{
GuiEntries entry = GuiEntries.fromId(fieldId);
if (entry == null) {return;}
switch (entry)
{
case GENERATE_BOP_GEMS:
this.settings.generateBopGems = value;
break;
case GENERATE_POISON_IVY:
this.settings.generatePoisonIvy = value;
break;
case GENERATE_BERRY_BUSHES:
this.settings.generateBerryBushes = value;
break;
case GENERATE_THORNS:
this.settings.generateThorns = value;
break;
case GENERATE_QUICKSAND:
this.settings.generateQuicksand = value;
break;
case GENERATE_LIQUID_POISON:
this.settings.generateLiquidPoison = value;
break;
case GENERATE_HOT_SPRINGS:
this.settings.generateHotSprings = value;
break;
case GENERATE_NETHER_HIVES:
this.settings.generateNetherHives = value;
break;
case GENERATE_END_FEATURES:
this.settings.generateEndFeatures = value;
break;
default:
break;
}
System.out.println("settings currently: "+this.settings.toJson());
}
@Override
public void handleFloatSelection(int fieldId, float value)
{
GuiEntries entry = GuiEntries.fromId(fieldId);
if (entry == null) {return;}
switch (entry)
{
case AMPLITUDE:
this.settings.amplitude = value;
break;
case MAIN_NOISE_SCALE_X:
this.settings.mainNoiseScaleX = value;
break;
case MAIN_NOISE_SCALE_Y:
this.settings.mainNoiseScaleY = value;
break;
case MAIN_NOISE_SCALE_Z:
this.settings.mainNoiseScaleZ = value;
break;
case COORDINATE_SCALE:
this.settings.coordinateScale = value;
break;
case HEIGHT_SCALE:
this.settings.heightScale = value;
break;
case UPPER_LIMIT_SCALE:
this.settings.upperLimitScale = value;
break;
case LOWER_LIMIT_SCALE:
this.settings.lowerLimitScale = value;
break;
default:
break;
}
System.out.println("settings currently: "+this.settings.toJson());
}
@Override
public void handleStringSelection(int fieldId, String value)
{
}
@Override
public void handleIntSelection(int fieldId, int value)
{
}
// These 3 are the original functions required by GuiPageButtonList.GuiResponder - just pass off to the better named functions
@Override
public void setEntryValue(int fieldId, String value) {this.handleStringSelection(fieldId, value);}
@Override
public void setEntryValue(int fieldId, float value) {this.handleFloatSelection(fieldId, value);}
@Override
public void setEntryValue(int fieldId, boolean value) {this.handleBooleanSelection(fieldId, value);}
@Override
protected void actionPerformed(GuiButton button) throws IOException
{
if (button.enabled)
{
Actions action = Actions.fromId(button.id);
if (action == null) {return;}
switch (action)
{
case DONE:
this.parentScreen.chunkProviderSettingsJson = this.settings.toJson();
System.out.println("settings sent to world screen "+this.parentScreen.chunkProviderSettingsJson);
this.mc.displayGuiScreen(this.parentScreen);
break;
case PREVIOUS:
this.pageManager.gotToPrevPage(); // prev page
this.showNewPage();
break;
case NEXT:
this.pageManager.goToNextPage(); // next page
this.showNewPage();
break;
case DEFAULTS:
this.confirmSetDefaults(button.id);
break;
case YES:
this.handleModalClose();
break;
case NO:
this.modalAction = 0;
this.handleModalClose();
}
}
}
private void doSetDefaults()
{
this.settings.setDefault();
this.setupPages();
}
private void confirmSetDefaults(int actionId)
{
this.modalAction = actionId;
this.showModal(true);
}
private void handleModalClose() throws IOException
{
Actions action = Actions.fromId(this.modalAction);
if (action != null) {
switch (action)
{
case DONE:
this.actionPerformed((GuiListButton)this.pageManager.getActivePage().getGui(300));
break;
case DEFAULTS:
this.doSetDefaults();
break;
default:
break;
}
}
this.modalAction = 0;
this.field_175340_C = true;
this.showModal(false);
}
private void showModal(boolean flag)
{
this.yesButton.visible = flag;
this.noButton.visible = flag;
this.doneButton.enabled = !flag;
this.prevButton.enabled = !flag;
this.nextButton.enabled = !flag;
this.defaultsButton.enabled = !flag;
}
private void showNewPage()
{
this.prevButton.enabled = this.pageManager.getActivePage().pageNumber != 0;
this.nextButton.enabled = this.pageManager.getActivePage().pageNumber != this.pageManager.getNumPages() - 1;
this.pageInfo = I18n.format("book.pageIndicator", Integer.valueOf(this.pageManager.getActivePage().pageNumber + 1), Integer.valueOf(this.pageManager.getNumPages()));
this.page0Title = this.pageNames[this.pageManager.getActivePage().pageNumber];
}
@Override
protected void keyTyped(char typedChar, int keyCode) throws IOException
{
super.keyTyped(typedChar, keyCode);
if (this.modalAction == 0)
{
switch (keyCode)
{
case 200:
this.func_175327_a(1.0F);
break;
case 208:
this.func_175327_a(-1.0F);
break;
default:
this.pageManager.getActivePage().keyTyped(typedChar, keyCode);
}
}
}
private void func_175327_a(float p_175327_1_)
{
Gui gui = this.pageManager.getActivePage().getFocusedGuiElement();
if (gui instanceof GuiTextField)
{
float f1 = p_175327_1_;
if (GuiScreen.isShiftKeyDown())
{
f1 = p_175327_1_ * 0.1F;
if (GuiScreen.isCtrlKeyDown())
{
f1 *= 0.1F;
}
}
else if (GuiScreen.isCtrlKeyDown())
{
f1 = p_175327_1_ * 10.0F;
if (GuiScreen.isAltKeyDown())
{
f1 *= 10.0F;
}
}
GuiTextField guitextfield = (GuiTextField)gui;
Float f2 = Floats.tryParse(guitextfield.getText());
if (f2 != null)
{
f2 = Float.valueOf(f2.floatValue() + f1);
int i = guitextfield.getId();
String s = this.stringFormatFloat(guitextfield.getId(), f2.floatValue());
guitextfield.setText(s);
this.setEntryValue(i, s);
}
}
}
@Override
public void drawScreen(int mouseX, int mouseY, float partialTicks)
{
this.drawDefaultBackground();
this.pageManager.getActivePage().drawScreen(mouseX, mouseY, partialTicks);
this.drawCenteredString(this.fontRenderer, this.screenTitle, this.width / 2, 2, 16777215);
this.drawCenteredString(this.fontRenderer, this.pageInfo, this.width / 2, 12, 16777215);
this.drawCenteredString(this.fontRenderer, this.page0Title, this.width / 2, 22, 16777215);
super.drawScreen(mouseX, mouseY, partialTicks);
if (this.modalAction != 0)
{
drawRect(0, 0, this.width, this.height, Integer.MIN_VALUE);
this.drawHorizontalLine(this.width / 2 - 91, this.width / 2 + 90, 99, -2039584);
this.drawHorizontalLine(this.width / 2 - 91, this.width / 2 + 90, 185, -6250336);
this.drawVerticalLine(this.width / 2 - 91, 99, 185, -2039584);
this.drawVerticalLine(this.width / 2 + 90, 99, 185, -6250336);
GlStateManager.disableLighting();
GlStateManager.disableFog();
Tessellator tessellator = Tessellator.getInstance();
BufferBuilder bufferBuilder = tessellator.getBuffer();
this.mc.getTextureManager().bindTexture(OPTIONS_BACKGROUND);
GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
bufferBuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
bufferBuilder.pos((double)(this.width / 2 - 90), 185.0D, 0.0D).tex(0.0D, 2.65625D).color(64, 64, 64, 64).endVertex();
bufferBuilder.pos((double)(this.width / 2 + 90), 185.0D, 0.0D).tex(5.625D, 2.65625D).color(64, 64, 64, 64).endVertex();
bufferBuilder.pos((double)(this.width / 2 + 90), 100.0D, 0.0D).tex(5.625D, 0.0D).color(64, 64, 64, 64).endVertex();
bufferBuilder.pos((double)(this.width / 2 - 90), 100.0D, 0.0D).tex(0.0D, 0.0D).color(64, 64, 64, 64).endVertex();
tessellator.draw();
this.drawCenteredString(this.fontRenderer, I18n.format("createWorld.customize.custom.confirmTitle"), this.width / 2, 105, 16777215);
this.drawCenteredString(this.fontRenderer, I18n.format("createWorld.customize.custom.confirm1"), this.width / 2, 125, 16777215);
this.drawCenteredString(this.fontRenderer, I18n.format("createWorld.customize.custom.confirm2"), this.width / 2, 135, 16777215);
this.yesButton.drawButton(this.mc, mouseX, mouseY, partialTicks);
this.noButton.drawButton(this.mc, mouseX, mouseY, partialTicks);
}
}
}

View File

@ -1,53 +0,0 @@
package biomesoplenty.client.gui;
import biomesoplenty.common.config.GameplayConfigurationHandler;
import biomesoplenty.common.remote.TrailManager;
import biomesoplenty.common.util.entity.PlayerUtil;
import biomesoplenty.core.BiomesOPlenty;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.util.text.translation.I18n;
import net.minecraftforge.common.config.ConfigElement;
import net.minecraftforge.fml.client.DefaultGuiFactory;
import net.minecraftforge.fml.client.config.DummyConfigElement.DummyCategoryElement;
import net.minecraftforge.fml.client.config.GuiConfig;
import net.minecraftforge.fml.client.config.IConfigElement;
import java.util.ArrayList;
import java.util.List;
import static biomesoplenty.common.config.GameplayConfigurationHandler.CONVENIENCE_SETTINGS;
import static biomesoplenty.common.config.MiscConfigurationHandler.*;
public class GuiBOPFactory extends DefaultGuiFactory
{
public GuiBOPFactory()
{
super(BiomesOPlenty.MOD_ID, BiomesOPlenty.MOD_NAME);
}
@Override
public GuiScreen createConfigGui(GuiScreen parentScreen)
{
return new GuiConfig(parentScreen, getConfigElements(), modid, false, false, title);
}
private static List<IConfigElement> getConfigElements()
{
List<IConfigElement> list = new ArrayList<IConfigElement>();
List<IConfigElement> convenience_settings = new ConfigElement(GameplayConfigurationHandler.config.getCategory(CONVENIENCE_SETTINGS.toLowerCase())).getChildElements();
List<IConfigElement> gui_settings = new ConfigElement(config.getCategory(GUI_SETTINGS.toLowerCase())).getChildElements();
List<IConfigElement> texture_settings = new ConfigElement(config.getCategory(VISUAL_SETTINGS.toLowerCase())).getChildElements();
List<IConfigElement> trail_settings = new ConfigElement(config.getCategory(TRAIL_SETTINGS.toLowerCase())).getChildElements();
list.add(new DummyCategoryElement(I18n.translateToLocal("config.category.convenienceSettings.title"), "config.category.convenienceSettings", convenience_settings));
list.add(new DummyCategoryElement(I18n.translateToLocal("config.category.guiSettings.title"), "config.category.guiSettings", gui_settings));
list.add(new DummyCategoryElement(I18n.translateToLocal("config.category.textureSettings.title"), "config.category.textureSettings", texture_settings));
if (TrailManager.trailsMap.containsKey(PlayerUtil.getClientPlayerUUID()))
{
list.add(new DummyCategoryElement(I18n.translateToLocal("config.category.trailSettings.title"), "config.category.trailSettings", trail_settings));
}
return list;
}
}

View File

@ -1,15 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.gui;
public class GuiBOPPageBiomes //extends GuiBOPPageDelegate
{
//Subclass implementing GuiListExtended.IGuiListEntry
//Icon, label
}

View File

@ -1,36 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.gui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiSlot;
public abstract class GuiBOPPageDelegate extends GuiSlot
{
public final int pageNumber;
public GuiBOPPageDelegate(int width, int height, int top, int bottom, int slotHeight, int pageNumber)
{
super(Minecraft.getMinecraft(), width, height, top, bottom, slotHeight);
this.pageNumber = pageNumber;
}
public abstract void setup();
public abstract void setVisible(boolean isVisible);
public void mouseClicked(int mouseX, int mouseY, int mouseEvent) {}
public void mouseReleased(int mouseX, int mouseY, int state) {}
public void keyTyped(char typedChar, int keyCode) {}
public Gui getFocusedGuiElement() { return null; }
public Gui getGui(int fieldId) { return null; }
}

View File

@ -1,383 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.gui;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiLabel;
import net.minecraft.client.gui.GuiListExtended;
import net.minecraft.client.gui.GuiPageButtonList;
import net.minecraft.client.gui.GuiSlider;
import net.minecraft.client.gui.GuiTextField;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
public abstract class GuiBOPPageList extends GuiBOPPageDelegate
{
public GuiBOPPageList(int width, int height, int top, int bottom, int slotHeight, int pageNumber)
{
super(width, height, top, bottom, slotHeight, pageNumber);
}
@Override
protected void elementClicked(int slotIndex, boolean isDoubleClick, int mouseX, int mouseY) {}
@Override
protected boolean isSelected(int slotIndex)
{
return false;
}
@Override
protected void drawBackground() {}
@Override
protected void drawSlot(int entryID, int p_180791_2_, int p_180791_3_, int p_180791_4_, int mouseXIn, int mouseYIn, float partialTicks)
{
this.getListEntry(entryID).drawEntry(entryID, p_180791_2_, p_180791_3_, this.getListWidth(), p_180791_4_, mouseXIn, mouseYIn, this.getSlotIndexFromScreenCoords(mouseXIn, mouseYIn) == entryID, partialTicks);
}
// updateItemPos
@Override
protected void updateItemPos(int p_178040_1_, int p_178040_2_, int p_178040_3_, float partialTicks)
{
this.getListEntry(p_178040_1_).updatePosition(p_178040_1_, p_178040_2_, p_178040_3_, partialTicks);
}
@Override
public void mouseClicked(int mouseX, int mouseY, int mouseEvent)
{
if (this.isMouseYWithinSlotBounds(mouseY))
{
int l = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
if (l >= 0)
{
int i1 = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
int j1 = this.top + 4 - this.getAmountScrolled() + l * this.slotHeight + this.headerPadding;
int k1 = mouseX - i1;
int l1 = mouseY - j1;
if (this.getListEntry(l).mousePressed(l, mouseX, mouseY, mouseEvent, k1, l1))
{
this.setEnabled(false);
}
}
}
}
@Override
public void mouseReleased(int mouseX, int mouseY, int state)
{
for (int l = 0; l < this.getSize(); ++l)
{
int i1 = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
int j1 = this.top + 4 - this.getAmountScrolled() + l * this.slotHeight + this.headerPadding;
int k1 = mouseX - i1;
int l1 = mouseY - j1;
this.getListEntry(l).mouseReleased(l, mouseX, mouseY, state, k1, l1);
}
this.setEnabled(true);
}
public abstract GuiListExtended.IGuiListEntry getListEntry(int rowNum);
@SideOnly(Side.CLIENT)
public static class GuiSlideEntry extends GuiBOPPageList.GuiFieldEntry
{
private final GuiSlider.FormatHelper formatHelper;
private final float min;
private final float max;
private final float value;
public GuiSlideEntry(int fieldId, String labelText, boolean isVisible, GuiSlider.FormatHelper formatHelper, float min, float max, float value)
{
super(fieldId, labelText, isVisible);
this.formatHelper = formatHelper;
this.min = min;
this.max = max;
this.value = value;
}
public GuiSlider.FormatHelper getFormatHelper()
{
return this.formatHelper;
}
public float getMin()
{
return this.min;
}
public float getMax()
{
return this.max;
}
public float getValue()
{
return this.value;
}
}
@SideOnly(Side.CLIENT)
public interface GuiResponder extends GuiPageButtonList.GuiResponder
{
void handleEnumSelection(int fieldId, int ordinal);
void handleBooleanSelection(int fieldId, boolean value);
void handleFloatSelection(int fieldId, float value);
void handleStringSelection(int fieldId, String value);
void handleIntSelection(int fieldId, int value);
}
@SideOnly(Side.CLIENT)
public static class GuiFieldEntry
{
private final int fieldID;
private final String labelText;
private final boolean isVisible;
public GuiFieldEntry(int fieldId, String labelText, boolean isVisible)
{
this.fieldID = fieldId;
this.labelText = labelText;
this.isVisible = isVisible;
}
public int getFieldId()
{
return this.fieldID;
}
public String getLabelText()
{
return this.labelText;
}
public boolean isVisible()
{
return this.isVisible;
}
}
@SideOnly(Side.CLIENT)
public static class GuiLabelEntry extends GuiFieldEntry
{
public GuiLabelEntry(int fieldId, String labelText, boolean isVisible)
{
super(fieldId, labelText, isVisible);
}
}
@SideOnly(Side.CLIENT)
public static class GuiRowEntry implements GuiListExtended.IGuiListEntry
{
private final Minecraft minecraft = Minecraft.getMinecraft();
private final Gui guiLeft;
private final Gui guiRight;
Gui focusedGui;
public GuiRowEntry(Gui guiLeft, Gui guiRight)
{
this.guiLeft = guiLeft;
this.guiRight = guiRight;
}
public Gui getGuiLeft()
{
return this.guiLeft;
}
public Gui getGuiRight()
{
return this.guiRight;
}
@Override
public void drawEntry(int slotIndex, int x, int y, int listWidth, int slotHeight, int mouseX, int mouseY, boolean isVisible, float partialTicks)
{
this.drawGui(this.guiLeft, y, mouseX, mouseY, false, partialTicks);
this.drawGui(this.guiRight, y, mouseX, mouseY, false, partialTicks);
}
private void drawGui(Gui gui, int y, int mouseX, int mouseY, boolean isVisible, float partialTicks)
{
if (gui != null)
{
if (gui instanceof GuiButton)
{
this.drawGuiButton((GuiButton)gui, y, mouseX, mouseY, isVisible, partialTicks);
}
else if (gui instanceof GuiTextField)
{
this.drawGuiTextField((GuiTextField)gui, y, isVisible);
}
else if (gui instanceof GuiLabel)
{
this.drawGuiLabel((GuiLabel)gui, y, mouseX, mouseY, isVisible);
}
}
}
private void drawGuiButton(GuiButton guiButton, int y, int mouseX, int mouseY, boolean isVisible, float partialTicks)
{
guiButton.y = y;
if (!isVisible)
{
guiButton.drawButton(this.minecraft, mouseX, mouseY, partialTicks);
}
}
private void drawGuiTextField(GuiTextField guiTextField, int y, boolean isVisible)
{
guiTextField.y = y;
if (!isVisible)
{
guiTextField.drawTextBox();
}
}
private void drawGuiLabel(GuiLabel guiLabel, int y, int mouseX, int mouseY, boolean isVisible)
{
guiLabel.y = y;
if (!isVisible)
{
guiLabel.drawLabel(this.minecraft, mouseX, mouseY);
}
}
// setSelected
public void updatePosition(int p_178011_1_, int p_178011_2_, int p_178011_3_, float partialTicks)
{
this.drawGui(this.guiLeft, p_178011_3_, 0, 0, true, partialTicks);
this.drawGui(this.guiRight, p_178011_3_, 0, 0, true, partialTicks);
}
@Override
public boolean mousePressed(int slotIndex, int x, int y, int mouseEvent, int relativeX, int relativeY)
{
return this.doMousePressed(this.guiLeft, x, y, mouseEvent) || this.doMousePressed(this.guiRight, x, y, mouseEvent);
}
private boolean doMousePressed(Gui gui, int x, int y, int mouseEvent)
{
if (gui == null)
{
return false;
}
else if (gui instanceof GuiButton)
{
if (((GuiButton)gui).mousePressed(this.minecraft, x, y))
{
this.focusedGui = gui;
return true;
}
else
{
return false;
}
}
else if (gui instanceof GuiTextField)
{
((GuiTextField)gui).mouseClicked(x, y, mouseEvent);
if (((GuiTextField)gui).isFocused())
{
this.focusedGui = gui;
}
return false;
}
return false;
}
@Override
public void mouseReleased(int slotIndex, int x, int y, int mouseEvent, int relativeX, int relativeY)
{
this.doMouseReleased(this.guiLeft, x, y);
this.doMouseReleased(this.guiRight, x, y);
}
public void doMouseReleased(Gui gui, int x, int y)
{
if (gui != null && (gui instanceof GuiButton))
{
((GuiButton)gui).mouseReleased(x, y);
}
}
}
@SideOnly(Side.CLIENT)
public static class GuiEnumButtonEntry<T extends Enum> extends GuiFieldEntry
{
private final T value;
public GuiEnumButtonEntry(int fieldId, String textLabel, boolean isVisible, T value)
{
super(fieldId, textLabel, isVisible);
this.value = value;
}
public T getValue()
{
return this.value;
}
}
@SideOnly(Side.CLIENT)
public static class GuiButtonEntry extends GuiFieldEntry
{
private final boolean value;
public GuiButtonEntry(int fieldId, String textLabel, boolean isVisible, boolean value)
{
super(fieldId, textLabel, isVisible);
this.value = value;
}
public boolean getValue()
{
return this.value;
}
}
@SideOnly(Side.CLIENT)
public static class EditBoxEntry extends GuiFieldEntry
{
private final Predicate validator;
public EditBoxEntry(int fieldId, String labelText, boolean isVisible, Predicate validator)
{
super(fieldId, labelText, isVisible);
this.validator = MoreObjects.firstNonNull(validator, Predicates.alwaysTrue());
}
public Predicate getValidator()
{
return this.validator;
}
}
}

View File

@ -1,61 +0,0 @@
package biomesoplenty.client.gui;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class GuiBOPPageManager
{
private GuiBOPPageDelegate[] pages;
private GuiBOPPageDelegate activePage;
public GuiBOPPageManager(GuiBOPPageDelegate ... pages)
{
this.pages = pages;
this.activePage = pages[0];
}
public void setup()
{
for (GuiBOPPageDelegate page : pages)
{
page.setup();
}
}
public GuiBOPPageDelegate getActivePage()
{
return this.activePage;
}
public int getNumPages()
{
return this.pages.length;
}
public void gotToPrevPage()
{
if (this.activePage.pageNumber > 0)
{
int newPageNumber = this.activePage.pageNumber - 1;
GuiBOPPageDelegate newPage = this.pages[newPageNumber];
this.activePage.setVisible(false);
newPage.setVisible(true);
this.activePage = newPage;
}
}
public void goToNextPage()
{
if (this.activePage.pageNumber < this.pages.length - 1)
{
int newPageNumber = this.activePage.pageNumber + 1;
GuiBOPPageDelegate newPage = this.pages[newPageNumber];
this.activePage.setVisible(false);
newPage.setVisible(true);
this.activePage = newPage;
}
}
}

View File

@ -1,370 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.gui;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.lwjgl.input.Mouse;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiLabel;
import net.minecraft.client.gui.GuiListButton;
import net.minecraft.client.gui.GuiListExtended;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.GuiSlider;
import net.minecraft.client.gui.GuiTextField;
public class GuiBOPPageTable extends GuiBOPPageList
{
private final List<GuiBOPPageList.GuiRowEntry> allRows = new ArrayList<GuiBOPPageList.GuiRowEntry>();
private final Map<Integer, Gui> fieldIdToGuiMap = new HashMap<Integer, Gui>();
private final List<GuiTextField> allTextFieldGuis = new ArrayList<GuiTextField>();
private final GuiBOPPageList.GuiFieldEntry[] fields;
private GuiBOPPageList.GuiResponder responder;
private Gui focusedGui;
public GuiBOPPageTable(int width, int height, int top, int bottom, int slotHeight, int pageNumber, GuiBOPPageList.GuiResponder responder, GuiBOPPageList.GuiFieldEntry... fields)
{
super(width, height, top, bottom, slotHeight, pageNumber);
this.responder = responder;
this.fields = fields;
}
@Override
public void setVisible(boolean isVisible)
{
if (isVisible)
{
for (GuiBOPPageList.GuiFieldEntry field : this.fields)
{
if (field != null)
{
Gui gui = this.fieldIdToGuiMap.get(field.getFieldId());
this.setVisible(gui, true);
}
}
}
else
{
for (GuiBOPPageList.GuiFieldEntry field : this.fields)
{
if (field != null)
{
Gui gui = this.fieldIdToGuiMap.get(field.getFieldId());
this.setVisible(gui, false);
}
}
}
}
private void setVisible(Gui gui, boolean isVisible)
{
if (gui instanceof GuiButton)
{
((GuiButton)gui).visible = isVisible;
}
else if (gui instanceof GuiTextField)
{
((GuiTextField)gui).setVisible(isVisible);
}
else if (gui instanceof GuiLabel)
{
((GuiLabel)gui).visible = isVisible;
}
}
@Override
public void setup()
{
// go through the fields in twos (so they go in 2 columns)
for (int k = 0; k < fields.length; k += 2)
{
GuiBOPPageList.GuiFieldEntry fieldLeft = fields[k];
GuiBOPPageList.GuiFieldEntry fieldRight = k < fields.length - 1 ? fields[k + 1] : null;
Gui guiLeft = this.createGui(fieldLeft, 0, fieldRight == null);
Gui guiRight = this.createGui(fieldRight, 160, fieldLeft == null);
GuiBOPPageList.GuiRowEntry row = new GuiBOPPageList.GuiRowEntry(guiLeft, guiRight);
this.allRows.add(row);
if (fieldLeft != null && guiLeft != null)
{
this.fieldIdToGuiMap.put(fieldLeft.getFieldId(), guiLeft);
if (guiLeft instanceof GuiTextField)
{
this.allTextFieldGuis.add((GuiTextField)guiLeft);
}
}
if (fieldRight != null && guiRight != null)
{
this.fieldIdToGuiMap.put(fieldRight.getFieldId(), guiRight);
if (guiRight instanceof GuiTextField)
{
this.allTextFieldGuis.add((GuiTextField)guiRight);
}
}
}
this.resetRows();
}
private void resetRows()
{
this.allRows.clear();
for (int i = 0; i < this.fields.length; i += 2)
{
GuiBOPPageList.GuiFieldEntry guilistentryLeft = this.fields[i];
GuiBOPPageList.GuiFieldEntry guilistentryRight = i < this.fields.length - 1 ? this.fields[i + 1] : null;
Gui guiLeft = this.fieldIdToGuiMap.get(guilistentryLeft.getFieldId());
Gui guiRight = guilistentryRight != null ? this.fieldIdToGuiMap.get(guilistentryRight.getFieldId()) : null;
GuiBOPPageList.GuiRowEntry guientry = new GuiBOPPageList.GuiRowEntry(guiLeft, guiRight);
this.allRows.add(guientry);
}
}
@Override
public Gui getFocusedGuiElement()
{
return this.focusedGui;
}
@Override
public Gui getGui(int fieldId)
{
return this.fieldIdToGuiMap.get(fieldId);
}
private Gui createGui(GuiBOPPageList.GuiFieldEntry field, int xOffset, boolean hasNoNeighbor)
{
if (field instanceof GuiBOPPageList.GuiSlideEntry)
{
return this.createSlider(this.width / 2 - 155 + xOffset, 0, (GuiSlideEntry)field);
}
else if (field instanceof GuiBOPPageList.GuiButtonEntry)
{
return this.createListButton(this.width / 2 - 155 + xOffset, 0, (GuiButtonEntry)field);
}
else if (field instanceof GuiBOPPageList.EditBoxEntry)
{
return this.createTextField(this.width / 2 - 155 + xOffset, 0, (EditBoxEntry)field);
}
else if (field instanceof GuiBOPPageList.GuiLabelEntry)
{
return this.createLabel(this.width / 2 - 155 + xOffset, 0, (GuiLabelEntry)field, hasNoNeighbor);
}
else if (field instanceof GuiBOPPageList.GuiEnumButtonEntry)
{
return this.createEnumButton(this.width / 2 - 155 + xOffset, 0, (GuiEnumButtonEntry)field);
}
else
{
return null;
}
}
//Mouse clicked
private GuiSlider createSlider(int xPosition, int yPosition, GuiBOPPageList.GuiSlideEntry field)
{
GuiSlider guislider = new GuiSlider(this.responder, field.getFieldId(), xPosition, yPosition, field.getLabelText(), field.getMin(), field.getMax(), field.getValue(), field.getFormatHelper());
guislider.visible = field.isVisible();
return guislider;
}
private GuiListButton createListButton(int xPosition, int yPosition, GuiBOPPageList.GuiButtonEntry field)
{
GuiListButton guilistbutton = new GuiListButton(this.responder, field.getFieldId(), xPosition, yPosition, field.getLabelText(), field.getValue());
guilistbutton.visible = field.isVisible();
return guilistbutton;
}
private GuiEnumButton createEnumButton(int xPosition, int yPosition, GuiBOPPageList.GuiEnumButtonEntry field)
{
GuiEnumButton guienumbutton = new GuiEnumButton(this.responder, field.getFieldId(), xPosition, yPosition, field.getLabelText(), field.getValue());
guienumbutton.visible = field.isVisible();
return guienumbutton;
}
private GuiTextField createTextField(int xPosition, int yPosition, GuiBOPPageList.EditBoxEntry field)
{
GuiTextField guitextfield = new GuiTextField(field.getFieldId(), this.mc.fontRenderer, xPosition, yPosition, 150, 20);
guitextfield.setText(field.getLabelText());
guitextfield.setGuiResponder(this.responder);
guitextfield.setVisible(field.isVisible());
guitextfield.setValidator(field.getValidator());
return guitextfield;
}
private GuiLabel createLabel(int xPosition, int yPosition, GuiBOPPageList.GuiLabelEntry field, boolean hasNoNeighbor)
{
GuiLabel guilabel;
if (hasNoNeighbor)
{
guilabel = new GuiLabel(this.mc.fontRenderer, field.getFieldId(), xPosition, yPosition, this.width - xPosition * 2, 20, -1);
}
else
{
guilabel = new GuiLabel(this.mc.fontRenderer, field.getFieldId(), xPosition, yPosition, 150, 20, -1);
}
guilabel.visible = field.isVisible();
guilabel.addLine(field.getLabelText());
guilabel.setCentered();
return guilabel;
}
@Override
public void keyTyped(char typedChar, int keyCode)
{
if (this.focusedGui instanceof GuiTextField)
{
GuiTextField guitextfield = (GuiTextField)this.focusedGui;
int j;
//Check if aren't we are pasting text
if (!GuiScreen.isKeyComboCtrlV(keyCode))
{
if (keyCode == 15) //Tab is pressed
{
guitextfield.setFocused(false);
int focusedGuiIndex = this.allTextFieldGuis.indexOf(this.focusedGui);
if (GuiScreen.isShiftKeyDown())
{
if (focusedGuiIndex == 0) //Jump back to the end of the list when at the start
{
focusedGuiIndex = this.allTextFieldGuis.size() - 1;
}
else
{
--focusedGuiIndex; //Cycle backwards through the text fields
}
}
else if (focusedGuiIndex == this.allTextFieldGuis.size() - 1) //Jump back to the start of the list when at the end
{
focusedGuiIndex = 0;
}
else
{
++focusedGuiIndex; //Cycle forwards through the text fields
}
this.focusedGui = this.allTextFieldGuis.get(focusedGuiIndex);
guitextfield = (GuiTextField)this.focusedGui;
guitextfield.setFocused(true);
int k1 = guitextfield.y + this.slotHeight;
j = guitextfield.y;
if (k1 > this.bottom)
{
this.amountScrolled += (float)(k1 - this.bottom);
}
else if (j < this.top)
{
this.amountScrolled = (float)j;
}
}
else
{
guitextfield.textboxKeyTyped(typedChar, keyCode);
}
}
else
{
String s = GuiScreen.getClipboardString();
String[] astring = s.split(";");
j = this.allTextFieldGuis.indexOf(this.focusedGui);
int k = j;
String[] astring1 = astring;
int l = astring.length;
for (int i1 = 0; i1 < l; ++i1)
{
String s1 = astring1[i1];
this.allTextFieldGuis.get(k).setText(s1);
if (k == this.allTextFieldGuis.size() - 1)
{
k = 0;
}
else
{
++k;
}
if (k == j)
{
break;
}
}
}
}
}
public GuiBOPPageList.GuiRowEntry getRow(int rowNum)
{
return this.allRows.get(rowNum);
}
@Override
public int getSize()
{
return this.allRows.size();
}
@Override
public int getListWidth()
{
return 400;
}
@Override
protected int getScrollBarX()
{
return super.getScrollBarX() + 32;
}
@Override
public GuiListExtended.IGuiListEntry getListEntry(int rowNum)
{
return this.getRow(rowNum);
}
@Override
public void mouseClicked(int mouseX, int mouseY, int mouseButton)
{
super.mouseClicked(mouseX, mouseY, Mouse.getEventButton());
int l = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
if (l >= 0)
{
GuiBOPPageTable.GuiRowEntry row = this.getRow(l);
if (this.focusedGui != row.focusedGui && this.focusedGui != null && this.focusedGui instanceof GuiTextField)
{
((GuiTextField)this.focusedGui).setFocused(false);
}
this.focusedGui = row.focusedGui;
}
}
}

View File

@ -1,54 +0,0 @@
package biomesoplenty.client.gui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.resources.I18n;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class GuiEnumButton<T extends Enum> extends GuiButton
{
private T value;
private String localizationStr;
private final GuiBOPPageList.GuiResponder guiResponder;
public GuiEnumButton(GuiBOPPageList.GuiResponder responder, int fieldId, int x, int y, String localizationStr, T initialValue)
{
super(fieldId, x, y, 150, 20, "");
this.localizationStr = localizationStr;
this.value = initialValue;
this.displayString = this.buildDisplayString();
this.guiResponder = responder;
}
private String buildDisplayString()
{
return I18n.format(this.localizationStr, this.value.toString());
}
public void setValue(T value)
{
this.value = value;
this.displayString = this.buildDisplayString();
this.guiResponder.handleEnumSelection(this.id, value.ordinal());
}
@Override
public boolean mousePressed(Minecraft mc, int mouseX, int mouseY)
{
if (super.mousePressed(mc, mouseX, mouseY))
{
Object[] values = this.value.getClass().getEnumConstants();
int len = values.length;
this.value = (T)(values[(this.value.ordinal() + 1) % len]);
this.displayString = this.buildDisplayString();
this.guiResponder.handleEnumSelection(this.id, this.value.ordinal());
return true;
}
else
{
return false;
}
}
}

View File

@ -0,0 +1,54 @@
package biomesoplenty.client.handler;
import biomesoplenty.init.ModBiomes;
import biomesoplenty.init.ModConfig;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.screen.*;
import net.minecraft.util.text.TranslationTextComponent;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.client.event.GuiOpenEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.common.Mod;
import java.util.Optional;
@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.FORGE)
public class GuiEventHandler
{
@OnlyIn(Dist.CLIENT)
@SubscribeEvent
public static void onGuiOpened(GuiOpenEvent event)
{
Screen gui = event.getGui();
Minecraft mc = Minecraft.getInstance();
Screen prevScreen = mc.screen;
// Default to the bop worldtype
if (ModConfig.ClientConfig.useWorldType.get() && gui instanceof CreateWorldScreen && prevScreen instanceof WorldSelectionScreen)
{
WorldOptionsScreen optionsScreen = ((CreateWorldScreen)gui).worldGenSettingsComponent;
optionsScreen.preset = Optional.of(findBopBiomeGeneratorTypeScreen());
optionsScreen.settings = optionsScreen.preset.get().create(optionsScreen.registryHolder, optionsScreen.settings.seed(), optionsScreen.settings.generateFeatures(), optionsScreen.settings.generateBonusChest());
}
}
private static BiomeGeneratorTypeScreens findBopBiomeGeneratorTypeScreen()
{
for (BiomeGeneratorTypeScreens screen : BiomeGeneratorTypeScreens.PRESETS)
{
// Skip screens that don't use a TranslationTextComponent because definitely they're not ours
if (!(screen.description instanceof TranslationTextComponent))
continue;
TranslationTextComponent desc = (TranslationTextComponent)screen.description;
if (desc.getKey().equals("generator.minecraft.biomesoplenty"))
{
return screen;
}
}
throw new RuntimeException("Failed to locate biomesoplenty biome generator type screen!");
}
}

View File

@ -1,130 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.particle;
import biomesoplenty.core.ClientProxy;
import net.minecraft.client.particle.Particle;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.Entity;
import net.minecraft.util.math.MathHelper;
import net.minecraft.world.World;
import net.minecraftforge.fml.client.FMLClientHandler;
public class EntityCurseFX extends Particle
{
private float defaultParticleScale;
public EntityCurseFX(World world, double xCoordIn, double yCoordIn, double zCoordIn, double motionXIn, double motionYIn, double motionZIn)
{
this(world, xCoordIn, yCoordIn, zCoordIn, motionXIn, motionYIn, motionZIn, 1.0F);
}
public EntityCurseFX(World world, double xCoordIn, double yCoordIn, double zCoordIn, double motionXIn, double motionYIn, double motionZIn, float par14)
{
super(world, xCoordIn, yCoordIn, zCoordIn, 0.0D, 0.0D, 0.0D);
this.particleTextureIndexX = 7;
this.particleTextureIndexY = 5;
this.motionX *= 0.10000000149011612D;
this.motionY *= 0.10000000149011612D;
this.motionZ *= 0.10000000149011612D;
this.motionX += motionXIn;
this.motionY += motionYIn;
this.motionZ += motionZIn;
this.particleScale = 1.0F;
this.defaultParticleScale = this.particleScale;
this.particleMaxAge = (int)((8.0D / (Math.random() * 0.8D + 0.2D)) * 8);
this.particleMaxAge = (int)((float)this.particleMaxAge * par14);
this.particleAge = world.rand.nextInt(3);
this.particleAlpha = 1.0F;
this.particleGravity = 0.02F;
this.canCollide = false;
}
@Override
public int getFXLayer()
{
return 2;
}
@Override
public void renderParticle(BufferBuilder buffer, Entity entity, float partialTicks, float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY)
{
// EffectRenderer will by default bind the vanilla particles texture, override with our own
FMLClientHandler.instance().getClient().renderEngine.bindTexture(ClientProxy.particleTexturesLocation);
float scaleMultiplier = ((float)this.particleAge + partialTicks) / (float)this.particleMaxAge * 32.0F;
scaleMultiplier = MathHelper.clamp(scaleMultiplier, 0.0F, 1.0F);
this.particleScale = this.defaultParticleScale * scaleMultiplier;
GlStateManager.depthMask(false);
GlStateManager.enableBlend();
GlStateManager.blendFunc(770, 1);
super.renderParticle(buffer, entity, partialTicks, rotX, rotXZ, rotZ, rotYZ, rotXY);
GlStateManager.disableBlend();
GlStateManager.depthMask(true);
}
@Override
public int getBrightnessForRender(float p_189214_1_)
{
float f = (float)this.particleMaxAge - (((float)this.particleAge + p_189214_1_) / (float)this.particleMaxAge);
f = MathHelper.clamp(f, 0.0F, 1.0F);
int i = super.getBrightnessForRender(p_189214_1_);
int j = i & 255;
int k = i >> 16 & 255;
j = j + (int)(f * 15.0F * 16.0F);
if (j > 240)
{
j = 240;
}
return j | k << 16;
}
@Override
public void onUpdate()
{
prevPosX = posX;
prevPosY = posY;
prevPosZ = posZ;
particleAge += 2;
if (particleAge >= particleMaxAge)
{
this.setExpired();
}
this.particleTextureIndexX = 7 - this.particleAge * 8 / this.particleMaxAge;
this.move(motionX, motionY, motionZ);
if (posY == prevPosY)
{
motionX *= 1.1D;
motionZ *= 1.1D;
}
motionX *= 0.9599999785423279D;
motionY *= 0.9599999785423279D;
motionZ *= 0.9599999785423279D;
if (onGround)
{
motionX *= 0.699999988079071D;
motionZ *= 0.699999988079071D;
}
}
}

View File

@ -1,80 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.particle;
import net.minecraft.client.particle.Particle;
import net.minecraft.client.renderer.BufferBuilder;
import net.minecraft.entity.Entity;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraftforge.fml.client.FMLClientHandler;
public class EntityTrailFX extends Particle
{
private ResourceLocation trailResource;
/**The index of the flower to be spawned, values are 0-3*/
private int particleIndex;
private double startY;
public EntityTrailFX(World world, double x, double y, double z, String trailName)
{
super(world, x, y, z);
this.trailResource = new ResourceLocation("biomesoplenty:textures/particles/" + trailName + ".png");
this.motionX = this.motionY = this.motionZ = 0.0D; //Trail particles should not move
this.particleMaxAge = 550;
this.particleIndex = this.rand.nextInt(4); //Choose a random index on creation
this.startY = y; //Where y coordinate where this particle has started (before it moves downwards with time)
}
@Override
public void renderParticle(BufferBuilder builder, Entity entity, float partialTicks, float rotX, float rotXZ, float rotZ, float rotYZ, float rotXY)
{
// EffectRenderer will by default bind the vanilla particles texture, override with our own
FMLClientHandler.instance().getClient().renderEngine.bindTexture(this.trailResource);
//The overall maxU and maxV of the particle sheet is 1.0 (representing 16px)
float minU = (particleIndex % 2) * 0.5F; //Particles on the left side are 0, right are 0.5
float maxU = minU + 0.5F; //Each flower is 8px wide (half of the overall sheet)
float minV = (particleIndex / 2) * 0.5F; //Uses integer rounding errors (0 and 1 = 0, 2 and 3 = 1)
float maxV = minV + 0.5F; //Each flower is 8px high (half of the overall sheet)
//Vanilla particle rendering
float alpha = 1.0F - Math.min(1.0F, 2.0F * this.particleAge / this.particleMaxAge);
float width = 0.15F;
float x = (float)(prevPosX + (posX - prevPosX) - interpPosX);
float y = (float)(prevPosY + (posY - prevPosY) - interpPosY);
float z = (float)(prevPosZ + (posZ - prevPosZ) - interpPosZ);
int i = this.getBrightnessForRender(partialTicks);
int j = i >> 16 & 65535;
int k = i & 65535;
builder.pos(x - width, y, z + width).tex(minU, maxV).color(this.particleRed, this.particleGreen, this.particleBlue, alpha).lightmap(j, k).endVertex();
builder.pos(x + width, y, z + width).tex(minU, minV).color(this.particleRed, this.particleGreen, this.particleBlue, alpha).lightmap(j, k).endVertex();
builder.pos(x + width, y, z - width).tex(maxU, minV).color(this.particleRed, this.particleGreen, this.particleBlue, alpha).lightmap(j, k).endVertex();
builder.pos(x - width, y, z - width).tex(maxU, maxV).color(this.particleRed, this.particleGreen, this.particleBlue, alpha).lightmap(j, k).endVertex();
}
@Override
public int getFXLayer()
{
return 2;
}
@Override
public void onUpdate()
{
super.onUpdate();
this.posY = this.startY - 0.01 * ((float)this.particleAge / (float)this.particleMaxAge);
this.prevPosY = this.posY;
}
}

View File

@ -0,0 +1,78 @@
package biomesoplenty.client.renderer;
import biomesoplenty.common.entity.item.BoatEntityBOP;
import com.mojang.blaze3d.matrix.MatrixStack;
import com.mojang.blaze3d.vertex.IVertexBuilder;
import net.minecraft.client.renderer.IRenderTypeBuffer;
import net.minecraft.client.renderer.RenderType;
import net.minecraft.client.renderer.entity.EntityRenderer;
import net.minecraft.client.renderer.entity.EntityRendererManager;
import net.minecraft.client.renderer.entity.model.BoatModel;
import net.minecraft.client.renderer.texture.OverlayTexture;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.vector.Quaternion;
import net.minecraft.util.math.vector.Vector3f;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import static biomesoplenty.core.BiomesOPlenty.MOD_ID;
@OnlyIn(Dist.CLIENT)
public class BoatRendererBOP extends EntityRenderer<BoatEntityBOP> {
protected final BoatModel model = new BoatModel();
public BoatRendererBOP(EntityRendererManager renderer) {
super(renderer);
this.shadowRadius = 0.8f;
}
@Override
public void render(BoatEntityBOP entity, float entityYaw, float partialTicks, MatrixStack matrixStack, IRenderTypeBuffer renderTypeBuffer, int light) {
matrixStack.pushPose();
matrixStack.translate(0d, 0.375d, 0d);
matrixStack.mulPose(Vector3f.YP.rotationDegrees(180f - entityYaw));
float f = (float) entity.getHurtTime() - partialTicks;
float f1 = entity.getDamage() - partialTicks;
if (f1 < 0f) {
f1 = 0f;
}
if (f > 0f) {
matrixStack.mulPose(Vector3f.XP.rotationDegrees(MathHelper.sin(f) * f * f1 / 10f * (float) entity.getHurtDir()));
}
float f2 = entity.getBubbleAngle(partialTicks);
if (!MathHelper.equal(f2, 0f)) {
matrixStack.mulPose(new Quaternion(new Vector3f(1f, 0f, 1f), entity.getBubbleAngle(partialTicks), true));
}
matrixStack.scale(-1f, -1f, 1f);
matrixStack.mulPose(Vector3f.YP.rotationDegrees(90.0F));
this.model.setupAnim(entity, partialTicks, 0f, -0.1f, 0f, 0f);
IVertexBuilder ivertexbuilder = renderTypeBuffer.getBuffer(this.model.renderType(this.getTextureLocation(entity)));
this.model.renderToBuffer(matrixStack, ivertexbuilder, light, OverlayTexture.NO_OVERLAY, 1f, 1f, 1f, 1f);
if (!entity.isUnderWater()) {
IVertexBuilder ivertexbuilder1 = renderTypeBuffer.getBuffer(RenderType.waterMask());
this.model.waterPatch().render(matrixStack, ivertexbuilder1, light, OverlayTexture.NO_OVERLAY);
}
matrixStack.popPose();
super.render(entity, entityYaw, partialTicks, matrixStack, renderTypeBuffer, light);
}
@Override
public ResourceLocation getTextureLocation(BoatEntityBOP entity) {
return BOAT_TEXTURE_LOCATIONS[entity.getModel().ordinal()];
}
private static final ResourceLocation[] BOAT_TEXTURE_LOCATIONS = new ResourceLocation[] {
new ResourceLocation(MOD_ID, "textures/entity/boat/fir.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/redwood.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/cherry.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/mahogany.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/jacaranda.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/palm.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/willow.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/dead.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/magic.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/umbran.png"),
new ResourceLocation(MOD_ID, "textures/entity/boat/hellbark.png")
};
}

View File

@ -1,43 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.util;
import com.google.common.base.Function;
import net.minecraft.client.renderer.block.model.IBakedModel;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.IModel;
public class ModelUtils
{
public static IBakedModel[] generateModelsForTextures(IModel model, TextureAtlasSprite[] textures)
{
IBakedModel[] output = new IBakedModel[textures.length];
for (int i = 0; i < output.length; i++)
{
final TextureAtlasSprite texture = textures[i];
//Defines how TextureAtlasSprites are obtained whilst baking
Function<ResourceLocation, TextureAtlasSprite> textureGetter = new Function<ResourceLocation, TextureAtlasSprite>()
{
public TextureAtlasSprite apply(ResourceLocation location)
{
return texture;
}
};
output[i] = model.bake(model.getDefaultState(), DefaultVertexFormats.ITEM, textureGetter);
}
return output;
}
}

View File

@ -1,21 +0,0 @@
/*******************************************************************************
* Copyright 2014-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.client.util;
import net.minecraft.util.ResourceLocation;
public class TextureUtils
{
public static final String TEXTURES_BASE_PATH = "textures";
public static ResourceLocation completeResourceLocation(ResourceLocation location, int mode)
{
return mode == 0 ? new ResourceLocation(location.getResourceDomain(), String.format("%s/%s%s", TEXTURES_BASE_PATH, location.getResourcePath(), ".png")) : new ResourceLocation(location.getResourceDomain(), String.format("%s/mipmaps/%s.%d%s", TEXTURES_BASE_PATH, location.getResourcePath(), Integer.valueOf(mode), ".png"));
}
}

View File

@ -1,328 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome;
import biomesoplenty.api.biome.BiomeOwner;
import biomesoplenty.api.biome.IExtendedBiome;
import biomesoplenty.api.config.IBOPWorldSettings;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.api.generation.IGenerator;
import biomesoplenty.common.init.ModBiomes;
import biomesoplenty.common.world.GenerationManager;
import biomesoplenty.core.BiomesOPlenty;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.biome.Biome;
import net.minecraftforge.fml.common.registry.ForgeRegistries;
import java.util.*;
public abstract class BOPBiome extends Biome implements IExtendedBiome
{
protected GenerationManager generationManager = new GenerationManager();
protected Map<BOPClimates, Integer> weightMap = new HashMap<BOPClimates, Integer>();
// defaults
// -1 indicates the defaults as set by Vanilla will be used for the below fields
public int skyColor = -1;
public int fogColor = -1;
/** 1.0 is the lowest possible amount of fog. 0.0 is the greatest.*/
public float fogDensity = 1.0F;
public boolean hasBiomeEssence = true;
public final ResourceLocation location;
public IConfigObj conf;
private BOPBiome(ResourceLocation idLoc, PropsBuilder defaultBuilder, IConfigObj conf)
{
super(configureBiomeProps(idLoc, defaultBuilder, conf));
this.location = idLoc;
this.conf = conf;
this.decorator.treesPerChunk = -999;
this.decorator.flowersPerChunk = -999;
this.decorator.grassPerChunk = -999;
this.decorator.gravelPatchesPerChunk = -999;
this.decorator.sandPatchesPerChunk = -999;
//this.theBiomeDecorator.generateLakes = false;
}
protected BOPBiome(String idName, PropsBuilder defaultBuilder)
{
this(new ResourceLocation(BiomesOPlenty.MOD_ID, idName), defaultBuilder, ModBiomes.readConfigFile(idName));
}
public static BOPBiome.BiomeProps configureBiomeProps(ResourceLocation idLoc, BOPBiome.PropsBuilder defaultBuilder, IConfigObj conf)
{
// If there isn't a valid config file, don't use it to configure the biome
if (conf.isEmpty())
return defaultBuilder.build();
defaultBuilder.withTemperature(conf.getFloat("temperature", defaultBuilder.temperature));
defaultBuilder.withRainfall(conf.getFloat("rainfall", defaultBuilder.rainfall));
defaultBuilder.withWaterColor(conf.getInt("waterColor", defaultBuilder.waterColor));
Boolean enableRain = conf.getBool("enableRain", defaultBuilder.enableRain);
if (enableRain != null && !enableRain) defaultBuilder.withRainDisabled();
Boolean enableSnow = conf.getBool("enableSnow", defaultBuilder.enableSnow);
if (enableSnow != null && enableSnow) defaultBuilder.withSnowEnabled();
defaultBuilder.withBaseBiome(conf.getString("baseBiome", defaultBuilder.baseBiomeRegName));
defaultBuilder.withGuiColour(conf.getInt("guiColour", defaultBuilder.guiColour));
return defaultBuilder.build();
}
@Override
public void applySettings(IBOPWorldSettings settings) {}
@Override
public void configure(IConfigObj conf)
{
this.topBlock = conf.getBlockState("topBlock", this.topBlock);
this.fillerBlock = conf.getBlockState("fillerBlock", this.fillerBlock);
this.skyColor = conf.getInt("skyColor", this.skyColor);
this.fogColor = conf.getInt("fogColor", this.fogColor);
this.fogDensity = conf.getFloat("fogDensity", this.fogDensity);
this.hasBiomeEssence = conf.getBool("hasBiomeEssence", this.hasBiomeEssence);
// Allow weights to be overridden
IConfigObj confWeights = conf.getObject("weights");
for (BOPClimates climate : BOPClimates.values())
{
Integer weight = confWeights.getInt(climate.name().toLowerCase(), this.weightMap.get(climate));
if (weight == null) {continue;}
if (weight.intValue() < 1)
{
this.weightMap.remove(climate);
}
else
{
this.weightMap.put(climate, weight);
}
}
// Allow generators to be configured
IConfigObj confGenerators = conf.getObject("generators");
this.generationManager.configure(confGenerators);
// Allow spawnable entites to be configured
ArrayList<IConfigObj> confEntities = conf.getObjectArray("entities");
if (confEntities != null)
{
for (IConfigObj confEntity : confEntities)
{
String entityName = confEntity.getString("name");
EnumCreatureType creatureType = confEntity.getEnum("creatureType", EnumCreatureType.class);
if (entityName == null || creatureType == null) {continue;}
// Look for an entity class matching this name
// case insensitive, dot used as mod delimiter, no spaces or underscores
// eg 'villager', 'Zombie', 'SQUID', 'enderdragon', 'biomesoplenty.wasp' all ok
Class <? extends Entity> entityClazz = ForgeRegistries.ENTITIES.getValue(new ResourceLocation(entityName)).getEntityClass();
Class <? extends EntityLiving> livingClazz = null;
if (!(entityClazz.isAssignableFrom(EntityLiving.class))) {
confEntity.addMessage("Entity " + entityName + " is not of type EntityLiving");
continue;
}
else {
livingClazz = (Class <? extends EntityLiving>)entityClazz;
}
if (livingClazz == null)
{
confEntity.addMessage("No entity registered called " + entityName);
continue;
}
if (!creatureType.getCreatureClass().isAssignableFrom(livingClazz))
{
confEntity.addMessage("Entity " + entityName + " is not of type " + creatureType);
continue;
}
List<SpawnListEntry> spawns = this.getSpawnableList(creatureType);
Integer weight = confEntity.getInt("weight");
if (weight != null && weight < 1)
{
// weight was set to zero (or negative) so find and remove this spawn
Iterator<SpawnListEntry> spawnIterator = spawns.iterator();
while (spawnIterator.hasNext())
{
SpawnListEntry entry = spawnIterator.next();
if (entry.entityClass == livingClazz)
{
spawnIterator.remove();
}
}
}
else
{
// weight was positive, or omitted, so update an existing spawn or add a new spawn
boolean foundIt = false;
for (SpawnListEntry entry : spawns)
{
if (entry.entityClass == entityClazz)
{
// the entry already exists - adjust the params
entry.itemWeight = confEntity.getInt("weight", entry.itemWeight);
entry.minGroupCount = confEntity.getInt("minGroupCount", entry.minGroupCount);
entry.maxGroupCount = confEntity.getInt("maxGroupCount", entry.maxGroupCount);
foundIt = true;
}
}
if (!foundIt)
{
// the entry does not exist - add it
SpawnListEntry entry = new SpawnListEntry(livingClazz, confEntity.getInt("weight", 10), confEntity.getInt("minGroupCount", 4), confEntity.getInt("maxGroupCount", 4));
spawns.add(entry);
}
}
}
}
}
@Override
public BiomeOwner getBiomeOwner()
{
return BiomeOwner.BIOMESOPLENTY;
}
@Override
public void addGenerator(String name, GeneratorStage stage, IGenerator generator)
{
this.generationManager.addGenerator(name, stage, generator);
}
public IGenerator getGenerator(String name)
{
return this.generationManager.getGenerator(name);
}
public void removeGenerator(String name)
{
this.generationManager.removeGenerator(name);
}
@Override
public GenerationManager getGenerationManager()
{
return this.generationManager;
}
@Override
public Map<BOPClimates, Integer> getWeightMap()
{
return this.weightMap;
}
@Override
public void addWeight(BOPClimates climate, int weight)
{
this.weightMap.put(climate, weight);
}
@Override
public void clearWeights()
{
this.weightMap.clear();
}
// whether or not a biome essence item corresponding to this biome should be able to drop from biome blocks
public boolean hasBiomeEssence()
{
return this.hasBiomeEssence;
}
public int getFogColor(BlockPos pos) { return this.fogColor; }
public float getFogDensity(BlockPos pos) { return this.fogDensity; }
@Override
public int getSkyColorByTemp(float temperature)
{
return (this.skyColor == -1) ? super.getSkyColorByTemp(temperature) : this.skyColor;
}
@Override
public Biome getBaseBiome()
{
return this;
}
@Override
public ResourceLocation getResourceLocation()
{
return this.location;
}
public static class PropsBuilder
{
private final String biomeName;
/**The colour of this biome as seen in guis**/
private int guiColour = 0xffffff;
private float baseHeight = 0.1F;
private float heightVariation = 0.2F;
private float temperature = 0.5F;
private float rainfall = 0.5F;
private int waterColor = 16777215;
private boolean enableSnow = false;
private boolean enableRain = true;
private String baseBiomeRegName;
public PropsBuilder(String name) { this.biomeName = name; }
public PropsBuilder withGuiColour(Integer colour) { if (colour != null) this.guiColour = colour; return this; }
public PropsBuilder withTemperature(Float temperature) { if (temperature != null) this.temperature = temperature; return this; }
public PropsBuilder withRainfall(Float rainfall) { if (rainfall != null) this.rainfall = rainfall; return this; }
public PropsBuilder withBaseHeight(Float baseHeight) { if (baseHeight != null) this.baseHeight = baseHeight; return this; }
public PropsBuilder withHeightVariation(Float heightVariation) { if (heightVariation != null) this.heightVariation = heightVariation; return this; }
public PropsBuilder withRainDisabled() { this.enableRain = false; return this; }
public PropsBuilder withSnowEnabled() { this.enableSnow = true; return this; }
public PropsBuilder withWaterColor(Integer waterColor) { if (waterColor != null) this.waterColor = waterColor; return this; }
public PropsBuilder withBaseBiome(String name) { if (name != null) this.baseBiomeRegName = name; return this; }
public BiomeProps build()
{
return new BiomeProps(this.biomeName, this.temperature, this.rainfall, this.baseHeight, this.heightVariation, this.enableRain, this.enableSnow, this.waterColor, this.baseBiomeRegName, this.guiColour);
}
}
public static class BiomeProps extends BiomeProperties
{
/**The colour of this biome as seen in guis**/
private int guiColour = 0xffffff;
private BiomeProps(String name, float temperature, float rainfall, float baseHeight, float heightVariation, boolean enableRain, boolean enableSnow, int waterColor, String baseBiomeRegName, int guiColour)
{
super(name);
this.setTemperature(temperature);
this.setRainfall(rainfall);
this.setBaseHeight(baseHeight);
this.setHeightVariation(heightVariation);
if (!enableRain) this.setRainDisabled();
if (enableSnow) this.setSnowEnabled();
this.setWaterColor(waterColor);
this.setBaseBiome(baseBiomeRegName);
this.guiColour = guiColour;
}
}
}

View File

@ -0,0 +1,64 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome;
import com.google.common.collect.Maps;
import com.google.gson.annotations.SerializedName;
import java.util.Map;
import java.util.TreeMap;
public class BiomeConfigData
{
@SerializedName("standard_weights")
public TreeMap<String, WeightedBiomeEntry> standardBiomeWeights = Maps.newTreeMap();
@SerializedName("technical_biome_toggles")
public TreeMap<String, ToggleableBiomeEntry> technicalBiomeEntries = Maps.newTreeMap();
@SerializedName("sub_biome_weights")
public TreeMap<String, SubBiomeEntry> subBiomeEntries = Maps.newTreeMap();
@SerializedName("island_biome_toggles")
public TreeMap<String, ToggleableBiomeEntry> islandBiomeEntries = Maps.newTreeMap();
@SerializedName("vanilla_biome_weights")
public TreeMap<String, WeightedBiomeEntry> vanillaBiomeEntries = Maps.newTreeMap();
public static class WeightedBiomeEntry
{
public int weight;
public WeightedBiomeEntry(int weight)
{
this.weight = weight;
}
}
public static class ToggleableBiomeEntry
{
public boolean enabled;
public ToggleableBiomeEntry(boolean enabled)
{
this.enabled = enabled;
}
}
public static class SubBiomeEntry
{
public int weight;
public float rarity;
public SubBiomeEntry(int weight, float rarity)
{
this.weight = weight;
this.rarity = rarity;
}
}
}

View File

@ -0,0 +1,90 @@
/*******************************************************************************
* Copyright 2020, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.util.biome.BiomeUtil;
import com.google.common.collect.ImmutableMap;
import net.minecraft.util.RegistryKey;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.biome.Biomes;
import javax.annotation.Nullable;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
public class BiomeMetadata
{
private final ImmutableMap<BOPClimates, Integer> weightMap;
@Nullable
private final RegistryKey<Biome> beachBiome;
@Nullable
private final RegistryKey<Biome> riverBiome;
@Nullable
private final BiFunction<Double, Double, Integer> foliageColorFunction;
@Nullable
private final BiFunction<Double, Double, Integer> grassColorFunction;
@Nullable
private final BiFunction<Double, Double, Integer> waterColorFunction;
protected BiomeMetadata(Map<BOPClimates, Integer> weights, @Nullable RegistryKey<Biome> beachBiome, @Nullable RegistryKey<Biome> riverBiome, BiFunction<Double, Double, Integer> foliageColorFunction, BiFunction<Double, Double, Integer> grassColorFunction, BiFunction<Double, Double, Integer> waterColorFunction)
{
this.weightMap = ImmutableMap.copyOf(weights);
this.beachBiome = beachBiome;
this.riverBiome = riverBiome;
this.foliageColorFunction = foliageColorFunction;
this.grassColorFunction = grassColorFunction;
this.waterColorFunction = waterColorFunction;
}
public Map<BOPClimates, Integer> getWeightMap()
{
return this.weightMap;
}
@Nullable
public RegistryKey<Biome> getBeachBiome()
{
return this.beachBiome;
}
@Nullable
public RegistryKey<Biome> getRiverBiome()
{
return this.riverBiome;
}
@Nullable
public BiFunction<Double, Double, Integer> getFoliageColorFunction()
{
return this.foliageColorFunction;
}
@Nullable
public BiFunction<Double, Double, Integer> getGrassColorFunction()
{
return this.grassColorFunction;
}
@Nullable
public BiFunction<Double, Double, Integer> getWaterColorFunction()
{
return this.waterColorFunction;
}
public boolean hasWeights()
{
return !this.weightMap.isEmpty() && !this.weightMap.entrySet().stream().allMatch((entry) -> entry.getValue().equals(0));
}
}

View File

@ -0,0 +1,680 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.util.biome.BiomeUtil;
import biomesoplenty.common.util.config.JsonUtil;
import biomesoplenty.core.BiomesOPlenty;
import biomesoplenty.init.ModBiomes;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.gson.reflect.TypeToken;
import net.minecraft.util.RegistryKey;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.biome.Biome;
import net.minecraftforge.fml.loading.FMLPaths;
import net.minecraftforge.registries.ForgeRegistries;
import org.apache.commons.lang3.tuple.Pair;
import javax.annotation.Nullable;
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;
import java.util.function.Consumer;
public class BiomeRegistry
{
private static final String CONFIG_FILE_NAME = "biomes.json";
private static Map<RegistrationType, List<DeferredRegistration>> deferrances = Maps.newHashMap();
public static void deferStandardRegistration(BiomeTemplate biome, String name)
{
defer(RegistrationType.STANDARD_BIOME, new StandardBiomeRegistrationData(biome, name));
}
public static void deferTechnicalBiomeRegistration(BiomeTemplate biome, String name)
{
defer(RegistrationType.TECHNICAL_BIOME, new ToggleableStandardBiomeRegistrationData(biome, name, true));
}
public static void deferSubBiomeRegistration(RegistryKey<Biome> parent, RegistryKey<Biome> child, int weight, float rarity)
{
// Don't register sub biome if the parent or child don't exist
if (!BiomeUtil.exists(parent) || !BiomeUtil.exists(child)) {
return;
}
defer(RegistrationType.SUB_BIOME, new SubBiomeRegistrationData(parent, child, weight, rarity));
}
public static void deferIslandBiomeRegistration(RegistryKey<Biome> key, BOPClimates climate, int weight)
{
if (!BiomeUtil.exists(key))
return;
defer(RegistrationType.ISLAND_BIOME, new SingleClimateRegistrationData(key, climate, weight));
}
public static void deferVanillaBiomeRegistration(RegistryKey<Biome> key, BOPClimates climate, int weight)
{
if (!BiomeUtil.exists(key))
return;
defer(RegistrationType.VANILLA_BIOME, new SingleClimateRegistrationData(key, climate, weight));
}
public static void configureStandardBiomes()
{
List<DeferredRegistration> standardRegistrations = deferrances.get(RegistrationType.STANDARD_BIOME);
TreeMap<String, BiomeConfigData.WeightedBiomeEntry> defaultEntries = Maps.newTreeMap();
Map<String, StandardBiomeRegistrationData> regDataMap = Maps.newHashMap();
for (DeferredRegistration<StandardBiomeRegistrationData> registration : standardRegistrations)
{
StandardBiomeRegistrationData regData = registration.regData;
// Ignore biomes which don't have any weights set by default
if (regData.getMetadata().hasWeights())
{
String biomeName = new ResourceLocation(BiomesOPlenty.MOD_ID, regData.getName()).toString();
Pair<BOPClimates, Integer> primaryWeight = regData.getPrimaryWeight();
defaultEntries.put(biomeName, new BiomeConfigData.WeightedBiomeEntry(primaryWeight.getValue()));
regDataMap.put(biomeName, registration.regData);
}
}
BiomeConfigData defaultConfigData = new BiomeConfigData();
defaultConfigData.standardBiomeWeights = defaultEntries;
BiomeConfigData configData = getConfigData(defaultConfigData);
TreeMap<String, BiomeConfigData.WeightedBiomeEntry> revisedStandardBiomeWeights = Maps.newTreeMap(defaultEntries);
// Merge the config file with the default values
for (Map.Entry<String, BiomeConfigData.WeightedBiomeEntry> biomeEntry : configData.standardBiomeWeights.entrySet())
{
if (revisedStandardBiomeWeights.containsKey(biomeEntry.getKey()))
{
revisedStandardBiomeWeights.put(biomeEntry.getKey(), biomeEntry.getValue());
}
}
// Write back to the config file
configData.standardBiomeWeights = revisedStandardBiomeWeights;
JsonUtil.writeFile(getConfigFile(), configData);
for (Map.Entry<String, BiomeConfigData.WeightedBiomeEntry> biomeEntry : configData.standardBiomeWeights.entrySet())
{
String name = biomeEntry.getKey();
BiomeConfigData.WeightedBiomeEntry weight = biomeEntry.getValue();
// Replace the default weight map for this biome with those from the config file
if (regDataMap.containsKey(name))
{
StandardBiomeRegistrationData registrationData = regDataMap.get(name);
registrationData.setPrimaryWeight(weight.weight);
}
}
}
public static void configureTechnicalBiomes()
{
List<DeferredRegistration> biomeRegistrations = deferrances.get(RegistrationType.TECHNICAL_BIOME);
TreeMap<String, BiomeConfigData.ToggleableBiomeEntry> defaultBiomeEntries = Maps.newTreeMap();
for (DeferredRegistration<ToggleableStandardBiomeRegistrationData> registration : biomeRegistrations)
{
ToggleableStandardBiomeRegistrationData regData = registration.regData;
String biomeName = new ResourceLocation(BiomesOPlenty.MOD_ID, regData.getName()).toString();
defaultBiomeEntries.put(biomeName, new BiomeConfigData.ToggleableBiomeEntry(true));
}
BiomeConfigData defaultConfigData = new BiomeConfigData();
defaultConfigData.technicalBiomeEntries = defaultBiomeEntries;
BiomeConfigData configData = getConfigData(defaultConfigData);
TreeMap<String, BiomeConfigData.ToggleableBiomeEntry> revisedBiomeEntries = Maps.newTreeMap(defaultBiomeEntries);
// Merge the config file with the default values
for (Map.Entry<String, BiomeConfigData.ToggleableBiomeEntry> biomeEntry : configData.technicalBiomeEntries.entrySet())
{
if (revisedBiomeEntries.containsKey(biomeEntry.getKey()))
{
revisedBiomeEntries.put(biomeEntry.getKey(), biomeEntry.getValue());
}
}
// Write back to the config file
configData.technicalBiomeEntries = revisedBiomeEntries;
JsonUtil.writeFile(getConfigFile(), configData);
for (DeferredRegistration<ToggleableStandardBiomeRegistrationData> registration : biomeRegistrations)
{
ToggleableStandardBiomeRegistrationData regData = registration.regData;
String biomeName = new ResourceLocation(BiomesOPlenty.MOD_ID, regData.getName()).toString();
if (revisedBiomeEntries.containsKey(biomeName))
{
BiomeConfigData.ToggleableBiomeEntry entry = revisedBiomeEntries.get(biomeName);
if (!entry.enabled)
{
registration.regData.setEnabled(false);
}
}
}
}
public static void configureSubBiomes()
{
List<DeferredRegistration> subBiomeRegistrations = deferrances.get(RegistrationType.SUB_BIOME);
TreeMap<String, BiomeConfigData.SubBiomeEntry> defaultSubBiomeEntries = Maps.newTreeMap();
Map<String, SubBiomeRegistrationData> regDataMap = Maps.newHashMap();
for (DeferredRegistration<SubBiomeRegistrationData> registration : subBiomeRegistrations)
{
SubBiomeRegistrationData regData = registration.regData;
String biomeName = registration.regData.getChild().location().toString();
defaultSubBiomeEntries.put(biomeName, new BiomeConfigData.SubBiomeEntry(regData.getWeight(), regData.getRarity()));
regDataMap.put(biomeName, registration.regData);
}
BiomeConfigData defaultConfigData = new BiomeConfigData();
defaultConfigData.subBiomeEntries = defaultSubBiomeEntries;
BiomeConfigData configData = getConfigData(defaultConfigData);
TreeMap<String, BiomeConfigData.SubBiomeEntry> revisedSubBiomeEntries = Maps.newTreeMap(defaultSubBiomeEntries);
// Merge the config file with the default values
for (Map.Entry<String, BiomeConfigData.SubBiomeEntry> biomeEntry : configData.subBiomeEntries.entrySet())
{
if (revisedSubBiomeEntries.containsKey(biomeEntry.getKey()))
{
revisedSubBiomeEntries.put(biomeEntry.getKey(), biomeEntry.getValue());
}
}
// Write back to the config file
configData.subBiomeEntries = revisedSubBiomeEntries;
JsonUtil.writeFile(getConfigFile(), configData);
for (Map.Entry<String, BiomeConfigData.SubBiomeEntry> biomeEntry : configData.subBiomeEntries.entrySet())
{
String name = biomeEntry.getKey();
BiomeConfigData.SubBiomeEntry subBiomeEntry = biomeEntry.getValue();
// Replace the default values for this biome with those from the config file
if (regDataMap.containsKey(name))
{
SubBiomeRegistrationData registrationData = regDataMap.get(name);
registrationData.setWeight(subBiomeEntry.weight);
registrationData.setRarity(subBiomeEntry.rarity);
}
}
}
public static void configureIslandBiomes()
{
List<DeferredRegistration> biomeRegistrations = deferrances.get(RegistrationType.ISLAND_BIOME);
TreeMap<String, BiomeConfigData.ToggleableBiomeEntry> defaultBiomeEntries = Maps.newTreeMap();
for (DeferredRegistration<SingleClimateRegistrationData> registration : biomeRegistrations)
{
SingleClimateRegistrationData regData = registration.regData;
String biomeName = regData.getBiome().location().toString();
defaultBiomeEntries.put(biomeName, new BiomeConfigData.ToggleableBiomeEntry(true));
}
BiomeConfigData defaultConfigData = new BiomeConfigData();
defaultConfigData.islandBiomeEntries = defaultBiomeEntries;
BiomeConfigData configData = getConfigData(defaultConfigData);
TreeMap<String, BiomeConfigData.ToggleableBiomeEntry> revisedBiomeEntries = Maps.newTreeMap(defaultBiomeEntries);
// Merge the config file with the default values
for (Map.Entry<String, BiomeConfigData.ToggleableBiomeEntry> biomeEntry : configData.islandBiomeEntries.entrySet())
{
if (revisedBiomeEntries.containsKey(biomeEntry.getKey()))
{
revisedBiomeEntries.put(biomeEntry.getKey(), biomeEntry.getValue());
}
}
// Write back to the config file
configData.islandBiomeEntries = revisedBiomeEntries;
JsonUtil.writeFile(getConfigFile(), configData);
for (DeferredRegistration<SingleClimateRegistrationData> registration : biomeRegistrations)
{
SingleClimateRegistrationData regData = registration.regData;
String biomeName = regData.getBiome().location().toString();
if (revisedBiomeEntries.containsKey(biomeName))
{
BiomeConfigData.ToggleableBiomeEntry entry = revisedBiomeEntries.get(biomeName);
if (!entry.enabled)
{
registration.regData.setWeight(0);
}
}
}
}
public static void configureVanillaBiomes()
{
List<DeferredRegistration> biomeRegistrations = deferrances.get(RegistrationType.VANILLA_BIOME);
TreeMap<String, BiomeConfigData.WeightedBiomeEntry> defaultBiomeEntries = Maps.newTreeMap();
Map<String, SingleClimateRegistrationData> regDataMap = Maps.newHashMap();
for (DeferredRegistration<SingleClimateRegistrationData> registration : biomeRegistrations)
{
SingleClimateRegistrationData regData = registration.regData;
String biomeName = registration.regData.getBiome().location().toString();
defaultBiomeEntries.put(biomeName, new BiomeConfigData.WeightedBiomeEntry(regData.getWeight()));
regDataMap.put(biomeName, registration.regData);
}
BiomeConfigData defaultConfigData = new BiomeConfigData();
defaultConfigData.vanillaBiomeEntries = defaultBiomeEntries;
BiomeConfigData configData = getConfigData(defaultConfigData);
TreeMap<String, BiomeConfigData.WeightedBiomeEntry> revisedBiomeEntries = Maps.newTreeMap(defaultBiomeEntries);
// Merge the config file with the default values
for (Map.Entry<String, BiomeConfigData.WeightedBiomeEntry> biomeEntry : configData.vanillaBiomeEntries.entrySet())
{
if (revisedBiomeEntries.containsKey(biomeEntry.getKey()))
{
revisedBiomeEntries.put(biomeEntry.getKey(), biomeEntry.getValue());
}
}
// Write back to the config file
configData.vanillaBiomeEntries = revisedBiomeEntries;
JsonUtil.writeFile(getConfigFile(), configData);
for (Map.Entry<String, BiomeConfigData.WeightedBiomeEntry> biomeEntry : configData.vanillaBiomeEntries.entrySet())
{
String name = biomeEntry.getKey();
BiomeConfigData.WeightedBiomeEntry islandBiomeEntry = biomeEntry.getValue();
// Replace the default values for this biome with those from the config file
if (regDataMap.containsKey(name))
{
SingleClimateRegistrationData registrationData = regDataMap.get(name);
registrationData.setWeight(islandBiomeEntry.weight);
}
}
}
private static File getConfigDirFile()
{
Path configPath = FMLPaths.CONFIGDIR.get();
Path bopConfigPath = Paths.get(configPath.toAbsolutePath().toString(), "biomesoplenty");
return bopConfigPath.toFile();
}
private static File getConfigFile()
{
return new File(getConfigDirFile(), CONFIG_FILE_NAME);
}
private static BiomeConfigData getConfigData(BiomeConfigData defaultConfigData)
{
BiomeConfigData configData = JsonUtil.getOrCreateConfigFile(getConfigDirFile(), CONFIG_FILE_NAME, defaultConfigData, new TypeToken<BiomeConfigData>(){}.getType());
return configData;
}
private static <T extends IRegistrationData> void defer(RegistrationType type, T data)
{
if (!deferrances.containsKey(type))
deferrances.put(type, Lists.newArrayList());
List<DeferredRegistration> list = deferrances.get(type);
list.add(new DeferredRegistration(type.regFunc, data));
}
public static void finalizeRegistrations(RegistrationType type)
{
if (!deferrances.containsKey(type))
return;
if (type == RegistrationType.SUB_BIOME)
{
Set<RegistryKey<Biome>> children = Sets.newHashSet();
deferrances.get(RegistrationType.SUB_BIOME).forEach((reg) -> {
RegistryKey<Biome> biome = ((SubBiomeRegistrationData)reg.regData).getChild();
if (children.contains(biome))
{
throw new RuntimeException(String.format("Sub biome %s cannot be added to multiple parents", biome.location().toString()));
}
children.add(biome);
});
}
for (DeferredRegistration reg : deferrances.get(type))
{
reg.register();
}
}
public enum RegistrationType
{
STANDARD_BIOME((StandardBiomeRegistrationData data) -> {
Biome biome = data.getBiome();
BiomeMetadata metadata = data.getMetadata();
String name = data.getName();
// Don't register biomes with their weight set to 0, that normally have weights that are non-zero
if (!metadata.getWeightMap().isEmpty() && (data.weightMap.isEmpty() || data.weightMap.entrySet().stream().allMatch((entry) -> entry.getValue().equals(0))))
{
BiomesOPlenty.logger.debug("Weights absent for " + data.getName() + ", disabling...");
return;
}
biome.setRegistryName(new ResourceLocation(BiomesOPlenty.MOD_ID, name));
ForgeRegistries.BIOMES.register(biome);
for (Map.Entry<BOPClimates, Integer> entry : data.getWeights().entrySet())
{
if (entry != null && entry.getValue() > 0)
{
BOPClimates climate = entry.getKey();
int weight = entry.getValue();
BiomesOPlenty.logger.debug(String.format("%s weight set to %d for climate %s", name, weight, climate.name()));
climate.addBiome(weight, BiomeUtil.createKey(data.getBiome()));
}
}
if (data.getMetadata() != null)
{
ModBiomes.biomeMetadata.put(BiomeUtil.createKey(data.getBiome()), data.getMetadata());
}
}),
TECHNICAL_BIOME((ToggleableStandardBiomeRegistrationData data) -> {
Biome biome = data.getBiome();
String name = data.getName();
if (!data.getEnabled())
{
BiomesOPlenty.logger.debug("Technical biome " + data.getName() + " is disabled.");
return;
}
biome.setRegistryName(new ResourceLocation(BiomesOPlenty.MOD_ID, name));
ForgeRegistries.BIOMES.register(biome);
if (data.getMetadata() != null)
{
ModBiomes.biomeMetadata.put(BiomeUtil.createKey(data.getBiome()), data.getMetadata());
}
}),
SUB_BIOME((SubBiomeRegistrationData data) -> {
if (data.getWeight() == 0)
{
BiomesOPlenty.logger.debug("Weights absent for sub biome" + data.getChild().location().toString() + ", disabling...");
return;
}
String childName = data.getChild().location().toString();
BiomesOPlenty.logger.debug(String.format("Sub biome %s weight set to %d", childName, data.getWeight()));
ModBiomes.subBiomes.put(BiomeUtil.getBiomeId(data.getParent()), new ModBiomes.WeightedSubBiome(data.getChild(), data.getRarity(), data.getWeight()));
}),
ISLAND_BIOME((SingleClimateRegistrationData data) -> {
if (data.getWeight() == 0)
{
BiomesOPlenty.logger.debug("Weights absent for island biome" + data.getBiome().location().toString() + ", disabling...");
return;
}
String biomeName = data.getBiome().location().toString();
BiomesOPlenty.logger.debug(String.format("Island biome %s weight set to %d for climate %s", biomeName, data.getWeight(), data.getClimate().name()));
ModBiomes.islandBiomeIds.add(BiomeUtil.getBiomeId(data.getBiome()));
data.getClimate().addIslandBiome(data.getWeight(), data.getBiome());
}),
VANILLA_BIOME((SingleClimateRegistrationData data) -> {
if (data.getWeight() == 0)
{
BiomesOPlenty.logger.debug("Weights absent for vanilla biome" + data.getBiome().location().toString() + ", disabling...");
return;
}
data.getClimate().addBiome(data.getWeight(), data.getBiome());
});
public final Consumer<? extends IRegistrationData> regFunc;
RegistrationType(Consumer<? extends IRegistrationData> regFunc)
{
this.regFunc = regFunc;
}
}
private interface IRegistrationData
{
}
private static abstract class TemplateRegistrationData implements IRegistrationData
{
private final Biome biome;
private final BiomeMetadata metadata;
public TemplateRegistrationData(BiomeTemplate template)
{
this.biome = template.build();
this.metadata = template.buildMetadata();
}
public TemplateRegistrationData(Biome biome)
{
this.biome = biome;
this.metadata = null;
}
public Biome getBiome()
{
return this.biome;
}
@Nullable
public BiomeMetadata getMetadata()
{
return this.metadata;
}
}
private static class StandardBiomeRegistrationData extends TemplateRegistrationData
{
private final String name;
private Map<BOPClimates, Integer> weightMap;
public StandardBiomeRegistrationData(BiomeTemplate biome, String name)
{
super(biome);
this.name = name;
this.weightMap = Maps.newHashMap(this.getMetadata().getWeightMap());
this.ensureSingleWeight();
}
public String getName()
{
return this.name;
}
public ImmutableMap<BOPClimates, Integer> getWeights()
{
return ImmutableMap.copyOf(this.weightMap);
}
public int getWeight(BOPClimates climate)
{
return this.weightMap.get(climate);
}
public void setWeight(BOPClimates climate, int weight)
{
this.weightMap.put(climate, weight);
this.ensureSingleWeight();
}
public Pair<BOPClimates, Integer> getPrimaryWeight()
{
List<Pair<BOPClimates, Integer>> pairs = Lists.newArrayList();
this.weightMap.entrySet().forEach((entry) -> pairs.add(Pair.of(entry.getKey(), entry.getValue())));
return pairs.get(0);
}
public void setPrimaryWeight(int value)
{
BOPClimates climate = this.getPrimaryWeight().getKey();
this.setWeight(climate, value);
}
// This limitation is enforced for config file simplicity, and because we don't need it at this time
private void ensureSingleWeight()
{
if (this.weightMap.size() > 1)
{
throw new RuntimeException(String.format("%s cannot be assigned to multiple climates!\n%s", new ResourceLocation(BiomesOPlenty.MOD_ID, name).toString(), this.weightMap));
}
}
}
private static class SubBiomeRegistrationData implements IRegistrationData
{
private final RegistryKey<Biome> parent;
private final RegistryKey<Biome> child;
private int weight;
private float rarity;
public SubBiomeRegistrationData(RegistryKey<Biome> parent, RegistryKey<Biome> child, int weight, float rarity)
{
this.parent = parent;
this.child = child;
this.weight = weight;
this.rarity = rarity;
}
public RegistryKey<Biome> getParent()
{
return this.parent;
}
public RegistryKey<Biome> getChild()
{
return this.child;
}
public int getWeight()
{
return this.weight;
}
public void setWeight(int weight)
{
this.weight = weight;
}
public float getRarity()
{
return this.rarity;
}
public void setRarity(float rarity)
{
this.rarity = rarity;
}
}
private static class SingleClimateRegistrationData implements IRegistrationData
{
private final BOPClimates climate;
private final RegistryKey<Biome> biome;
private int weight;
public SingleClimateRegistrationData(RegistryKey<Biome> biome, BOPClimates climate, int weight)
{
this.biome = biome;
this.climate = climate;
this.weight = weight;
}
public RegistryKey<Biome> getBiome()
{
return this.biome;
}
public BOPClimates getClimate()
{
return this.climate;
}
public int getWeight()
{
return this.weight;
}
public void setWeight(int weight)
{
this.weight = weight;
}
}
private static class ToggleableStandardBiomeRegistrationData extends TemplateRegistrationData
{
private final String name;
private boolean enabled;
public ToggleableStandardBiomeRegistrationData(BiomeTemplate biome, String name, boolean enabled)
{
super(biome);
this.name = name;
this.enabled = enabled;
}
public String getName()
{
return this.name;
}
public boolean getEnabled()
{
return this.enabled;
}
public void setEnabled(boolean enabled)
{
this.enabled = enabled;
}
}
private static class DeferredRegistration<T extends IRegistrationData>
{
private final Consumer<T> regFunc;
private final T regData;
public DeferredRegistration(Consumer<T> regFunc, T regData)
{
this.regFunc = regFunc;
this.regData = regData;
}
public void register()
{
this.regFunc.accept(this.regData);
}
}
}

View File

@ -0,0 +1,101 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome;
import biomesoplenty.api.enums.BOPClimates;
import net.minecraft.util.RegistryKey;
import net.minecraft.util.math.MathHelper;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.biome.BiomeGenerationSettings;
import net.minecraft.world.biome.Biomes;
import net.minecraft.world.biome.MobSpawnInfo;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
public class BiomeTemplate
{
private Map<BOPClimates, Integer> weightMap = new HashMap<BOPClimates, Integer>();
private RegistryKey<Biome> beachBiome = Biomes.BEACH;
private RegistryKey<Biome> riverBiome = Biomes.RIVER;
private BiFunction<Double, Double, Integer> foliageColorFunction;
private BiFunction<Double, Double, Integer> grassColorFunction;
private BiFunction<Double, Double, Integer> waterColorFunction;
protected void configureBiome(Biome.Builder builder) {}
protected void configureGeneration(BiomeGenerationSettings.Builder builder) {}
protected void configureMobSpawns(MobSpawnInfo.Builder builder) {}
protected void configureDefaultMobSpawns(MobSpawnInfo.Builder builder)
{
builder.setPlayerCanSpawn();
}
public final Biome build()
{
Biome.Builder biomeBuilder = new Biome.Builder();
// Configure the biome generation
BiomeGenerationSettings.Builder biomeGenBuilder = new BiomeGenerationSettings.Builder();
this.configureGeneration(biomeGenBuilder);
biomeBuilder.generationSettings(biomeGenBuilder.build());
// Configure mob spawning
MobSpawnInfo.Builder mobSpawnBuilder = new MobSpawnInfo.Builder();
this.configureDefaultMobSpawns(mobSpawnBuilder);
this.configureMobSpawns(mobSpawnBuilder);
biomeBuilder.mobSpawnSettings(mobSpawnBuilder.build());
// Configure and build the biome
this.configureBiome(biomeBuilder);
return biomeBuilder.build();
}
public final BiomeMetadata buildMetadata()
{
return new BiomeMetadata(this.weightMap, this.beachBiome, this.riverBiome, this.foliageColorFunction, this.grassColorFunction, this.waterColorFunction);
}
public void addWeight(BOPClimates climate, int weight)
{
this.weightMap.put(climate, weight);
}
public void setBeachBiome(RegistryKey<Biome> biome)
{
this.beachBiome = biome;
}
public void setRiverBiome(RegistryKey<Biome> biome)
{
this.riverBiome = biome;
}
public void setFoliageColorFunction(BiFunction<Double, Double, Integer> func)
{
this.foliageColorFunction = func;
}
public void setGrassColorFunction(BiFunction<Double, Double, Integer> func)
{
this.grassColorFunction = func;
}
public void setWaterColorFunction(BiFunction<Double, Double, Integer> func)
{
this.waterColorFunction = func;
}
public static int calculateSkyColor(float temperature)
{
float lvt_1_1_ = temperature / 3.0F;
lvt_1_1_ = MathHelper.clamp(lvt_1_1_, -1.0F, 1.0F);
return MathHelper.hsvToRgb(0.62222224F - lvt_1_1_ * 0.05F, 0.5F + lvt_1_1_ * 0.1F, 1.0F);
}
}

View File

@ -0,0 +1,18 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome;
import net.minecraft.world.biome.MobSpawnInfo;
public class NetherBiomeTemplate extends BiomeTemplate
{
protected void configureDefaultMobSpawns(MobSpawnInfo.Builder builder)
{
// Do nothing
}
}

View File

@ -1,181 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.nether;
import java.util.Random;
import biomesoplenty.api.config.IBOPWorldSettings;
import biomesoplenty.api.config.IBOPWorldSettings.GeneratorType;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.biome.BOPBiome;
import biomesoplenty.common.init.ModBiomes;
import biomesoplenty.common.world.generator.GeneratorHive;
import biomesoplenty.core.BiomesOPlenty;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.monster.EntityEnderman;
import net.minecraft.entity.monster.EntityGhast;
import net.minecraft.entity.monster.EntityMagmaCube;
import net.minecraft.entity.monster.EntityPigZombie;
import net.minecraft.init.Blocks;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.chunk.ChunkPrimer;
public class BOPHellBiome extends BOPBiome
{
public IBlockState wallBlock = Blocks.NETHERRACK.getDefaultState();
public IBlockState roofTopBlock = Blocks.NETHERRACK.getDefaultState();
public IBlockState roofFillerBlock = Blocks.NETHERRACK.getDefaultState();
public BOPHellBiome(String idName, PropsBuilder defaultBuilder)
{
super(idName, defaultBuilder);
this.topBlock = Blocks.NETHERRACK.getDefaultState();
this.fillerBlock = Blocks.NETHERRACK.getDefaultState();
this.spawnableCaveCreatureList.clear();
this.spawnableCreatureList.clear();
this.spawnableMonsterList.clear();
this.spawnableWaterCreatureList.clear();
this.spawnableMonsterList.add(new SpawnListEntry(EntityGhast.class, 50, 4, 4));
this.spawnableMonsterList.add(new SpawnListEntry(EntityPigZombie.class, 100, 4, 4));
this.spawnableMonsterList.add(new SpawnListEntry(EntityMagmaCube.class, 2, 4, 4));
this.spawnableMonsterList.add(new SpawnListEntry(EntityEnderman.class, 1, 4, 4));
this.addGenerator("hive", GeneratorStage.PRE, (new GeneratorHive.Builder()).amountPerChunk(0.2F).create());
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
// Allow basic properties to be overridden
this.wallBlock = conf.getBlockState("wallBlock", this.wallBlock);
this.roofTopBlock = conf.getBlockState("roofTopBlock", this.roofTopBlock);
this.roofFillerBlock = conf.getBlockState("roofFillerBlock", this.roofFillerBlock);
// log any warnings from parsing the config file
for (String msg : conf.flushMessages())
BiomesOPlenty.logger.info(msg);
// write default values to a file
ModBiomes.writeDefaultConfigFile(ModBiomes.BOP_DEFAULTS_DIR, this.getResourceLocation().getResourcePath(), conf);
}
@Override
public void applySettings(IBOPWorldSettings settings)
{
if (!settings.isEnabled(GeneratorType.GEMS)) {this.removeGenerator("ruby"); this.removeGenerator("topaz");
this.removeGenerator("amber"); this.removeGenerator("peridot"); this.removeGenerator("malachite");
this.removeGenerator("sapphire"); this.removeGenerator("tanzanite"); this.removeGenerator("amethyst");}
if (!settings.isEnabled(GeneratorType.POISON_IVY)) {this.removeGenerator("poison_ivy");}
if (!settings.isEnabled(GeneratorType.BERRY_BUSHES)) {this.removeGenerator("berry_bushes");}
if (!settings.isEnabled(GeneratorType.NETHER_HIVES)) {this.removeGenerator("hive");}
if (!settings.isEnabled(GeneratorType.THORNS)) {this.removeGenerator("thorns");}
if (!settings.isEnabled(GeneratorType.QUICKSAND)) {this.removeGenerator("quicksand");}
if (!settings.isEnabled(GeneratorType.HOT_SPRINGS)) {this.removeGenerator("hot_springs");}
if (!settings.isEnabled(GeneratorType.LIQUID_POISON)) {this.removeGenerator("poison_lakes");}
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double stoneNoiseVal)
{
IBlockState roof = this.roofTopBlock;
IBlockState roofFiller = this.roofFillerBlock;
IBlockState wall = this.wallBlock;
IBlockState floor = this.topBlock;
IBlockState floorFiller = this.fillerBlock;
int roofDepth = 4;
int floorDepth = 4;
int localX = x & 15;
int localZ = z & 15;
int localY = 127;
boolean lastSolid = true;
while (localY >= 0)
{
int blockSkip = 1;
IBlockState currentState = primer.getBlockState(localZ, localY, localX);
if (currentState.getBlock() == Blocks.NETHERRACK)
{
// initially set to the wall material. this may be replaced later by a roof
primer.setBlockState(localZ, localY, localX, wall);
// this must be a floor
if (!lastSolid)
{
primer.setBlockState(localZ, localY, localX, floor);
// iterate over the next few blocks and replace them with the floor material. skip those
// blocks too as we've already checked and modified them
for (int floorOffset = 1; floorOffset <= floorDepth - 1 && localY - floorOffset >= 0; floorOffset++)
{
IBlockState state = primer.getBlockState(localZ, localY - floorOffset, localX);
blockSkip = floorOffset + 1;
if (state.getBlock() == Blocks.NETHERRACK)
{
primer.setBlockState(localZ, localY - floorOffset, localX, floorFiller);
}
else break;
}
}
// update lastSolid for next time
lastSolid = true;
}
else if (currentState.getMaterial() == Material.AIR)
{
// previous blocks must be a roof
if (lastSolid)
{
primer.setBlockState(localZ, localY + 1, localX, roof);
// iterate over the previous few blocks to replace them with the roof material
for (int roofOffset = 2; roofOffset <= roofDepth && localY + roofOffset <= 127; roofOffset++)
{
IBlockState state = primer.getBlockState(localZ, localY + roofOffset, localX);
// onllocalY replace netherrack or walls, if it's air or anything else then don't continue
if (state.getBlock() == Blocks.NETHERRACK || state == wall)
{
primer.setBlockState(localZ, localY + roofOffset, localX, roofFiller);
}
else break;
}
}
// update lastSolid for next time
lastSolid = false;
}
localY -= blockSkip;
}
}
@Override
public ResourceLocation getBeachLocation()
{
return null;
}
}

View File

@ -1,42 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorBramble;
import biomesoplenty.common.world.generator.GeneratorFlora;
import net.minecraft.init.Blocks;
public class BiomeCorruptedSands extends BOPHellBiome
{
public BiomeCorruptedSands()
{
super("corrupted_sands", new PropsBuilder("Corrupted Sands").withGuiColour(0xA93C3E).withTemperature(2.0F).withRainfall(0.0F).withRainDisabled());
this.addWeight(BOPClimates.HELL, 5);
this.topBlock = Blocks.SOUL_SAND.getDefaultState();
this.fillerBlock = Blocks.SOUL_SAND.getDefaultState();
this.wallBlock = Blocks.SOUL_SAND.getDefaultState();
this.hasBiomeEssence = false;
IBlockPosQuery emptySoulsand = BlockQuery.buildAnd().withAirAbove().states(this.topBlock).create();
this.addGenerator("bramble", GeneratorStage.FLOWERS,(new GeneratorBramble.Builder()).amountPerChunk(40.0F).placeOn(emptySoulsand).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
// splatter top blocks
//this.addGenerator("netherrack_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(5.0F).generationAttempts(128).scatterYMethod(ScatterYMethod.NETHER_SURFACE).replace(emptySoulsand).with(Blocks.NETHERRACK.getDefaultState()).create());
this.addGenerator("dead_grass", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(5.0F).with(BOPPlants.DEADGRASS).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("thorns", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(3.0F).placeOn(emptySoulsand).with(BOPPlants.THORN).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
}
}

View File

@ -1,70 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.nether;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorBigMushroom;
import biomesoplenty.common.world.generator.GeneratorFlora;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.world.World;
import net.minecraft.world.chunk.ChunkPrimer;
public class BiomeFungiForest extends BOPHellBiome
{
public IBlockState usualTopBlock;
public IBlockState alternateTopBlock;
public BiomeFungiForest()
{
super("fungi_forest", new PropsBuilder("Fungi Forest").withGuiColour(0xA93C3E).withTemperature(2.0F).withRainfall(0.0F).withRainDisabled());
this.addWeight(BOPClimates.HELL, 5);
this.hasBiomeEssence = false;
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.MYCELIAL_NETHERRACK);
// shrooms
IBlockPosQuery surfaceBlocks = BlockQuery.buildOr().states(this.topBlock).create();
this.addGenerator("glowshroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.5F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.GLOWSHROOM).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("flat_mushroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.TOADSTOOL).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(5.0F).generationAttempts(16).with(Blocks.RED_MUSHROOM.getDefaultState()).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(2.0F).generationAttempts(16).with(Blocks.BROWN_MUSHROOM.getDefaultState()).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("big_brown_mushroom", GeneratorStage.BIG_SHROOM,(new GeneratorBigMushroom.Builder()).amountPerChunk(2.0F).mushroomType(GeneratorBigMushroom.BigMushroomType.BROWN).scatterYMethod(ScatterYMethod.NETHER_SURFACE).placeOn(surfaceBlocks).create());
this.addGenerator("big_red_mushroom", GeneratorStage.BIG_SHROOM,(new GeneratorBigMushroom.Builder()).amountPerChunk(30.0F).mushroomType(GeneratorBigMushroom.BigMushroomType.RED).scatterYMethod(ScatterYMethod.NETHER_SURFACE).minHeight(5).maxHeight(10).placeOn(surfaceBlocks).create());
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = conf.getBlockState("alternateTopBlock", this.alternateTopBlock);
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double noise)
{
this.topBlock = (noise + rand.nextDouble() * 1.0D > 1.8D) ? this.alternateTopBlock : this.usualTopBlock;
super.genTerrainBlocks(world, rand, primer, x, z, noise);
}
}

View File

@ -1,43 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorLakes;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
public class BiomePhantasmagoricInferno extends BOPHellBiome
{
public BiomePhantasmagoricInferno()
{
super("phantasmagoric_inferno", new PropsBuilder("Phantasmagoric Inferno").withGuiColour(0xA93C3E).withTemperature(2.0F).withRainfall(0.0F).withRainDisabled());
this.addWeight(BOPClimates.HELL, 5);
this.hasBiomeEssence = false;
this.topBlock = BOPBlocks.ash_block.getDefaultState();
this.fillerBlock = BOPBlocks.ash_block.getDefaultState();
// lava lakes
this.addGenerator("lava_lakes", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(4.0F).liquid(Blocks.LAVA).frozenLiquid((IBlockState)null).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
// splatter top blocks
IBlockPosQuery emptyAsh = BlockQuery.buildAnd().withAirAbove().states(this.topBlock).create();
this.addGenerator("fire", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(2.5F).with(Blocks.FIRE.getDefaultState()).placeOn(emptyAsh).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
this.addGenerator("blue_fire", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(2.5F).with(BOPBlocks.blue_fire.getDefaultState()).placeOn(emptyAsh).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
}
}

View File

@ -1,74 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPLeaves;
import biomesoplenty.common.block.BlockBOPLog;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorSplatter;
import biomesoplenty.common.world.generator.GeneratorVines;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.init.Blocks;
public class BiomeUndergarden extends BOPHellBiome
{
public BiomeUndergarden()
{
super("undergarden", new PropsBuilder("Undergarden").withGuiColour(0xA93C3E).withTemperature(2.0F).withRainfall(0.0F).withRainDisabled());
this.addWeight(BOPClimates.HELL, 5);
this.hasBiomeEssence = false;
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.OVERGROWN_NETHERRACK);
// splatter top blocks
IBlockPosQuery emptyOvergrownNetherrack = BlockQuery.buildAnd().withAirAbove().states(this.topBlock).create();
this.addGenerator("netherrack_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(7.0F).generationAttempts(128).scatterYMethod(ScatterYMethod.NETHER_SURFACE).replace(emptyOvergrownNetherrack).with(Blocks.NETHERRACK.getDefaultState()).create());
IBlockPosQuery suitableNetherrackPosition = BlockQuery.buildAnd().withAltitudeBetween(70, 120).states(Blocks.NETHERRACK.getDefaultState()).create();
this.addGenerator("ivy", GeneratorStage.FLOWERS,(new GeneratorVines.Builder()).amountPerChunk(25.0F).generationAttempts(128).placeOn(suitableNetherrackPosition).with(BOPBlocks.ivy.getDefaultState()).minHeight(8).maxHeight(20).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(1.0F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("burning_blossom", 4, (new GeneratorFlora.Builder().scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(BOPFlowers.BURNING_BLOSSOM).create()));
// trees
IBlockPosQuery surfaceBlocks = BlockQuery.buildOr().states(this.topBlock, BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.OVERGROWN_NETHERRACK)).create();
GeneratorWeighted treeGenerator = new GeneratorWeighted(15.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("twiglet", 5, (new GeneratorTwigletTree.Builder()).scatterYMethod(ScatterYMethod.NETHER_SURFACE).placeOn(surfaceBlocks).minHeight(2).maxHeight(2).log(BlockBOPLog.paging.getVariantState(BOPWoods.HELLBARK)).leaves(BlockBOPLeaves.paging.getVariantState(BOPTrees.HELLBARK)).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(15.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("devilweed", 5, (new GeneratorGrass.Builder()).with(BOPPlants.DEVILWEED).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
// shrooms
this.addGenerator("flat_mushroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).generationAttempts(16).scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).create());
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.5F).generationAttempts(16).scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(BlockBOPMushroom.MushroomType.TOADSTOOL).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(2.0F).generationAttempts(16).scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).generationAttempts(16).scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(Blocks.BROWN_MUSHROOM.getDefaultState()).create());
}
}

View File

@ -1,47 +0,0 @@
/*******************************************************************************
* Copyright 2014-2017, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorLakes;
import net.minecraft.block.BlockBone;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.util.EnumFacing;
public class BiomeVisceralHeap extends BOPHellBiome
{
public BiomeVisceralHeap()
{
super("visceral_heap", new PropsBuilder("Visceral Heap").withGuiColour(0xA93C3E).withTemperature(2.0F).withRainfall(0.0F).withRainDisabled());
this.addWeight(BOPClimates.HELL, 5);
this.hasBiomeEssence = false;
this.topBlock = BOPBlocks.flesh.getDefaultState();
this.fillerBlock = BOPBlocks.flesh.getDefaultState();
this.wallBlock = BOPBlocks.flesh.getDefaultState();
// blood pools
this.addGenerator("blood_pools", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(6.0F).liquid(BOPBlocks.blood).frozenLiquid((IBlockState)null).scatterYMethod(ScatterYMethod.NETHER_SURFACE).create());
IBlockPosQuery emptyFlesh = BlockQuery.buildAnd().withAirAbove().states(this.topBlock).create();
this.addGenerator("bones", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(1.5F).placeOn(emptyFlesh).scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(Blocks.BONE_BLOCK.getDefaultState().withProperty(BlockBone.AXIS, EnumFacing.Axis.Y)).minHeight(1).maxHeight(4).create());
this.addGenerator("eyebulbs", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).generationAttempts(16).amountPerChunk(1.0F).scatterYMethod(ScatterYMethod.NETHER_SURFACE).with(BlockBOPDoublePlant.DoublePlantType.EYEBULB).create());
}
}

View File

@ -0,0 +1,69 @@
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.NetherBiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import net.minecraft.client.audio.BackgroundMusicTracks;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.particles.ParticleTypes;
import net.minecraft.util.SoundEvents;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.carver.ConfiguredCarvers;
import net.minecraft.world.gen.feature.Features;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilders;
import net.minecraft.world.gen.surfacebuilders.SurfaceBuilder;
public class CrystallineChasmBiome extends NetherBiomeTemplate
{
public CrystallineChasmBiome()
{
this.addWeight(BOPClimates.NETHER, 5);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.NONE).biomeCategory(Biome.Category.NETHER).depth(0.1F).scale(0.2F).temperature(2.0F).downfall(0.0F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(0x59002C).skyColor(calculateSkyColor(2.0F)).ambientParticle(new ParticleEffectAmbience(ParticleTypes.INSTANT_EFFECT, 0.001785F)).ambientLoopSound(SoundEvents.AMBIENT_CRIMSON_FOREST_LOOP).ambientMoodSound(new MoodSoundAmbience(SoundEvents.AMBIENT_BASALT_DELTAS_MOOD, 6000, 8, 2.0D)).ambientAdditionsSound(new SoundAdditionsAmbience(SoundEvents.AMBIENT_BASALT_DELTAS_ADDITIONS, 0.0111D)).backgroundMusic(BackgroundMusicTracks.createGameMusic(SoundEvents.MUSIC_BIOME_NETHER_WASTES)).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(ConfiguredSurfaceBuilders.NETHER);
//Terrain
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_NETHER);
builder.addStructureStart(StructureFeatures.NETHER_BRIDGE);
builder.addStructureStart(StructureFeatures.BASTION_REMNANT);
builder.addCarver(GenerationStage.Carving.AIR, ConfiguredCarvers.NETHER_CAVE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.SPRING_OPEN);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.PATCH_FIRE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.PATCH_SOUL_FIRE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.GLOWSTONE_EXTRA);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.GLOWSTONE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.BROWN_MUSHROOM_NETHER);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.RED_MUSHROOM_NETHER);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.ORE_MAGMA);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.SPRING_CLOSED);
//Decoration
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.LARGE_CRYSTAL);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.SMALL_CRYSTAL);
DefaultBiomeFeatures.addNetherDefaultOres(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
//Entities
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.STRIDER, 60, 1, 2));
}
}

View File

@ -0,0 +1,77 @@
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.NetherBiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import net.minecraft.client.audio.BackgroundMusicTracks;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.particles.ParticleTypes;
import net.minecraft.util.SoundEvents;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.carver.ConfiguredCarvers;
import net.minecraft.world.gen.feature.Features;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilders;
import net.minecraft.world.gen.surfacebuilders.SurfaceBuilder;
public class UndergrowthBiome extends NetherBiomeTemplate
{
public UndergrowthBiome()
{
this.addWeight(BOPClimates.NETHER, 10);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.NONE).biomeCategory(Biome.Category.NETHER).depth(0.1F).scale(0.2F).temperature(2.0F).downfall(0.0F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(0x1C2109).skyColor(calculateSkyColor(2.0F)).ambientParticle(new ParticleEffectAmbience(ParticleTypes.MYCELIUM, 0.00714F)).ambientLoopSound(SoundEvents.AMBIENT_WARPED_FOREST_LOOP).ambientMoodSound(new MoodSoundAmbience(SoundEvents.AMBIENT_CRIMSON_FOREST_MOOD, 6000, 8, 2.0D)).ambientAdditionsSound(new SoundAdditionsAmbience(SoundEvents.AMBIENT_NETHER_WASTES_ADDITIONS, 0.0111D)).backgroundMusic(BackgroundMusicTracks.createGameMusic(SoundEvents.MUSIC_BIOME_NETHER_WASTES)).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(ConfiguredSurfaceBuilders.NETHER);
//Terrain
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_NETHER);
builder.addStructureStart(StructureFeatures.NETHER_BRIDGE);
builder.addStructureStart(StructureFeatures.BASTION_REMNANT);
builder.addCarver(GenerationStage.Carving.AIR, ConfiguredCarvers.NETHER_CAVE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.SPRING_OPEN);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.PATCH_FIRE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.PATCH_SOUL_FIRE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.GLOWSTONE_EXTRA);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.GLOWSTONE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.BROWN_MUSHROOM_NETHER);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.RED_MUSHROOM_NETHER);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.ORE_MAGMA);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.SPRING_CLOSED);
//Vegetation
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.UNDERGROWTH_TREES);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.NETHER_BRAMBLE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.UNDERGROWTH_FLOWERS);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.SPROUTS_UNDERGROWTH);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.DEAD_GRASS_45);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.NETHER_VINES);
DefaultBiomeFeatures.addNetherDefaultOres(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
//Entities
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.GHAST, 50, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.MAGMA_CUBE, 2, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.HOGLIN, 9, 3, 4));
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.STRIDER, 60, 1, 2));
}
}

View File

@ -0,0 +1,65 @@
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.NetherBiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import biomesoplenty.common.world.gen.surfacebuilders.BOPConfiguredSurfaceBuilders;
import biomesoplenty.common.world.gen.surfacebuilders.BOPSurfaceBuilders;
import net.minecraft.client.audio.BackgroundMusicTracks;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.particles.ParticleTypes;
import net.minecraft.util.SoundEvents;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.carver.ConfiguredCarvers;
import net.minecraft.world.gen.feature.Features;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
import net.minecraft.world.gen.surfacebuilders.SurfaceBuilder;
public class VisceralHeapBiome extends NetherBiomeTemplate
{
public VisceralHeapBiome()
{
this.addWeight(BOPClimates.NETHER, 7);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.NONE).biomeCategory(Biome.Category.NETHER).depth(0.1F).scale(0.2F).temperature(2.0F).downfall(0.0F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(0x601F18).skyColor(calculateSkyColor(2.0F)).ambientParticle(new ParticleEffectAmbience(ParticleTypes.FALLING_LAVA, 0.001785F)).ambientLoopSound(SoundEvents.AMBIENT_NETHER_WASTES_LOOP).ambientMoodSound(new MoodSoundAmbience(SoundEvents.AMBIENT_SOUL_SAND_VALLEY_MOOD, 6000, 8, 2.0D)).ambientAdditionsSound(new SoundAdditionsAmbience(SoundEvents.AMBIENT_CRIMSON_FOREST_ADDITIONS, 0.0111D)).backgroundMusic(BackgroundMusicTracks.createGameMusic(SoundEvents.MUSIC_BIOME_CRIMSON_FOREST)).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(BOPConfiguredSurfaceBuilders.VISCERAL_HEAP);
//Terrain
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_NETHER);
builder.addStructureStart(StructureFeatures.NETHER_BRIDGE);
builder.addStructureStart(StructureFeatures.BASTION_REMNANT);
builder.addCarver(GenerationStage.Carving.AIR, ConfiguredCarvers.NETHER_CAVE);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.SPRING_OPEN);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.ORE_MAGMA);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, Features.SPRING_CLOSED);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.FLESH_TENDON);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.BONE_SPINE);
DefaultBiomeFeatures.addNetherDefaultOres(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
//Entities
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.GHAST, 50, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIFIED_PIGLIN, 100, 4, 4));
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.STRIDER, 60, 1, 2));
}
}

View File

@ -0,0 +1,57 @@
package biomesoplenty.common.biome.nether;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.NetherBiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import biomesoplenty.common.world.gen.surfacebuilders.BOPConfiguredSurfaceBuilders;
import biomesoplenty.common.world.gen.surfacebuilders.BOPSurfaceBuilders;
import net.minecraft.client.audio.BackgroundMusicTracks;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.particles.ParticleTypes;
import net.minecraft.util.SoundEvents;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.carver.ConfiguredCarvers;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
public class WitheredAbyssBiome extends NetherBiomeTemplate
{
public WitheredAbyssBiome()
{
this.addWeight(BOPClimates.NETHER, 3);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.NONE).biomeCategory(Biome.Category.NETHER).depth(0.1F).scale(0.2F).temperature(2.0F).downfall(0.0F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(0x09060F).skyColor(calculateSkyColor(2.0F)).ambientParticle(new ParticleEffectAmbience(ParticleTypes.SMOKE, 0.00357F)).ambientLoopSound(SoundEvents.AMBIENT_SOUL_SAND_VALLEY_LOOP).ambientMoodSound(new MoodSoundAmbience(SoundEvents.AMBIENT_SOUL_SAND_VALLEY_MOOD, 6000, 8, 2.0D)).backgroundMusic(BackgroundMusicTracks.createGameMusic(SoundEvents.MUSIC_BIOME_BASALT_DELTAS)).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(BOPConfiguredSurfaceBuilders.WITHERED_ABYSS);
//Terrain
builder.addStructureStart(StructureFeatures.NETHER_BRIDGE);
builder.addStructureStart(StructureFeatures.BASTION_REMNANT);
builder.addCarver(GenerationStage.Carving.AIR, ConfiguredCarvers.NETHER_CAVE);
//Decoration
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_DECORATION, BOPConfiguredFeatures.OBSIDIAN_SPLATTER);
DefaultBiomeFeatures.addNetherDefaultOres(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
//Entities
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ENDERMAN, 1, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.WITHER_SKELETON, 1, 1, 1));
}
}

View File

@ -0,0 +1,71 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.BiomeTemplate;
import biomesoplenty.common.world.gen.surfacebuilders.BOPConfiguredSurfaceBuilders;
import biomesoplenty.common.world.gen.surfacebuilders.BOPSurfaceBuilders;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
public class AlpsBiome extends BiomeTemplate
{
public AlpsBiome()
{
this.addWeight(BOPClimates.ICE_CAP, 5);
this.setBeachBiome(null);
this.setRiverBiome(null);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.SNOW).biomeCategory(Biome.Category.ICY).depth(7.5F).scale(0.2F).temperature(-0.25F).downfall(0.3F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(12638463).skyColor(calculateSkyColor(-0.25F)).ambientMoodSound(MoodSoundAmbience.LEGACY_CAVE_SETTINGS).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(BOPConfiguredSurfaceBuilders.DEEP_SNOW);
// Structures
DefaultBiomeFeatures.addDefaultOverworldLandStructures(builder);
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_MOUNTAIN);
// Underground
DefaultBiomeFeatures.addDefaultCarvers(builder);
DefaultBiomeFeatures.addDefaultMonsterRoom(builder);
DefaultBiomeFeatures.addDefaultUndergroundVariety(builder);
DefaultBiomeFeatures.addDefaultOres(builder);
DefaultBiomeFeatures.addDefaultSoftDisks(builder);
// Other Features
DefaultBiomeFeatures.addDefaultSprings(builder);
DefaultBiomeFeatures.addExtraEmeralds(builder);
DefaultBiomeFeatures.addInfestedStone(builder);
DefaultBiomeFeatures.addSurfaceFreezing(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
// Entities
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.LLAMA, 5, 4, 6));
builder.addSpawn(EntityClassification.AMBIENT, new MobSpawnInfo.Spawners(EntityType.BAT, 10, 8, 8));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SKELETON, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SLIME, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ENDERMAN, 10, 1, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.STRAY, 80, 4, 4));
}
}

View File

@ -0,0 +1,83 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.common.biome.BiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import biomesoplenty.common.world.gen.surfacebuilders.BOPConfiguredSurfaceBuilders;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
import net.minecraft.world.gen.surfacebuilders.SurfaceBuilder;
public class AlpsFoothillsBiome extends BiomeTemplate
{
public AlpsFoothillsBiome()
{
this.setBeachBiome(null);
this.setRiverBiome(null);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.SNOW).biomeCategory(Biome.Category.ICY).depth(3.0F).scale(0.3F).temperature(-0.25F).downfall(0.3F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(12638463).skyColor(calculateSkyColor(-0.25F)).ambientMoodSound(MoodSoundAmbience.LEGACY_CAVE_SETTINGS).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(BOPConfiguredSurfaceBuilders.ALPS_FOOTHILLS);
// Structures
DefaultBiomeFeatures.addDefaultOverworldLandStructures(builder);
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_MOUNTAIN);
// Underground
DefaultBiomeFeatures.addDefaultCarvers(builder);
DefaultBiomeFeatures.addDefaultMonsterRoom(builder);
DefaultBiomeFeatures.addDefaultUndergroundVariety(builder);
DefaultBiomeFeatures.addDefaultOres(builder);
DefaultBiomeFeatures.addDefaultSoftDisks(builder);
////////////////////////////////////////////////////////////
// Vegetation
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.ALPS_FOOTHILLS_TREES);
////////////////////////////////////////////////////////////
// Other Features
DefaultBiomeFeatures.addDefaultSprings(builder);
DefaultBiomeFeatures.addExtraEmeralds(builder);
DefaultBiomeFeatures.addInfestedStone(builder);
DefaultBiomeFeatures.addSurfaceFreezing(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
// Entities
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.LLAMA, 5, 4, 6));
builder.addSpawn(EntityClassification.AMBIENT, new MobSpawnInfo.Spawners(EntityType.BAT, 10, 8, 8));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SPIDER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE, 95, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE_VILLAGER, 5, 1, 1));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SKELETON, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.CREEPER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SLIME, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ENDERMAN, 10, 1, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.WITCH, 5, 1, 1));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.STRAY, 80, 4, 4));
}
}

View File

@ -1,225 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IBOPWorldSettings;
import biomesoplenty.api.config.IBOPWorldSettings.GeneratorType;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.biome.BOPBiome;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.init.ModBiomes;
import biomesoplenty.common.util.biome.BiomeUtils;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.TerrainSettings;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.core.BiomesOPlenty;
import net.minecraft.block.BlockSand;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Biomes;
import net.minecraft.init.Blocks;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;
import net.minecraft.world.chunk.ChunkPrimer;
public class BOPOverworldBiome extends BOPBiome
{
public IBlockState seaFloorBlock = Blocks.DIRT.getDefaultState();
public boolean canSpawnInBiome = true;
public boolean canGenerateVillages = true;
public boolean canGenerateRivers = true;
public ResourceLocation beachBiomeLocation = BiomeUtils.getLocForBiome(Biomes.BEACH);
public TerrainSettings terrainSettings = new TerrainSettings();
public boolean noNeighborTerrainInfuence = false;
public int avgDirtDepth = 3;
public BOPOverworldBiome(String idName, PropsBuilder defaultBuilder)
{
super(idName, defaultBuilder);
this.terrainSettings.setDefaults();
// roots
this.addGenerator("roots", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(4.0F).with(BOPPlants.ROOT).create());
IBlockPosQuery suitableStonePosition = BlockQuery.buildAnd().withAltitudeBetween(0, 55).blocks(Blocks.STONE).create();
this.addGenerator("miners_delight", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.25F).generationAttempts(64).with(BOPFlowers.MINERS_DELIGHT).placeOn(suitableStonePosition).scatterYMethod(ScatterYMethod.BELOW_GROUND).create());
this.addGenerator("glowshrooms", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.5F).generationAttempts(64).placeOn(suitableStonePosition).with(BOPBlocks.mushroom.getDefaultState().withProperty(BlockBOPMushroom.VARIANT, BlockBOPMushroom.MushroomType.GLOWSHROOM)).scatterYMethod(ScatterYMethod.BELOW_GROUND).create());
}
@Override
public void applySettings(IBOPWorldSettings settings)
{
if (!settings.isEnabled(GeneratorType.GEMS)) {this.removeGenerator("ruby"); this.removeGenerator("topaz");
this.removeGenerator("amber"); this.removeGenerator("peridot"); this.removeGenerator("malachite");
this.removeGenerator("sapphire"); this.removeGenerator("tanzanite"); this.removeGenerator("amethyst");}
if (!settings.isEnabled(GeneratorType.POISON_IVY)) {this.removeGenerator("poison_ivy");}
if (!settings.isEnabled(GeneratorType.BERRY_BUSHES)) {this.removeGenerator("berry_bushes");}
if (!settings.isEnabled(GeneratorType.NETHER_HIVES)) {this.removeGenerator("hive");}
if (!settings.isEnabled(GeneratorType.THORNS)) {this.removeGenerator("thorns");}
if (!settings.isEnabled(GeneratorType.QUICKSAND)) {this.removeGenerator("quicksand");}
if (!settings.isEnabled(GeneratorType.HOT_SPRINGS)) {this.removeGenerator("hot_springs");}
if (!settings.isEnabled(GeneratorType.LIQUID_POISON)) {this.removeGenerator("poison_lakes");}
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
// Allow basic properties to be overridden
this.seaFloorBlock = conf.getBlockState("seaFloorBlock", this.seaFloorBlock);
this.terrainSettings.avgHeight = conf.getFloat("averageHeight", (float)this.terrainSettings.avgHeight);
this.terrainSettings.variationBelow = conf.getFloat("variationBelow", (float)this.terrainSettings.variationBelow);
this.terrainSettings.variationAbove = conf.getFloat("variationAbove", (float)this.terrainSettings.variationAbove);
this.canSpawnInBiome = conf.getBool("canSpawnInBiome", this.canSpawnInBiome);
this.canGenerateVillages = conf.getBool("canGenerateVillages", this.canGenerateVillages);
this.canGenerateRivers = conf.getBool("canGenerateRivers", this.canGenerateRivers);
this.beachBiomeLocation = conf.getResourceLocation("beachBiomeLocation", this.beachBiomeLocation);
// log any warnings from parsing the config file
for (String msg : conf.flushMessages())
BiomesOPlenty.logger.info(msg);
// write default values to a file
ModBiomes.writeDefaultConfigFile(ModBiomes.BOP_DEFAULTS_DIR, this.getResourceLocation().getResourcePath(), conf);
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double stoneNoiseVal)
{
IBlockState topBlock = this.topBlock;
IBlockState fillerBlock = this.fillerBlock;
IBlockState seaFloorBlock = this.seaFloorBlock;
boolean hitFloorYet = false;
int topBlocksToFill = 0;
int dirtBlocksToFill = 0;
int seaFloorBlocksToFill = 0;
int dirtDepth = Math.max(0, (int)(stoneNoiseVal / 3.0D + this.avgDirtDepth + rand.nextDouble() * 0.25D));
int seaFloorDepth = 1 + rand.nextInt(2);
int localX = x & 15;
int localZ = z & 15;
// start at the top and move downwards
for (int y = 255; y >= 0; --y)
{
IBlockState state = primer.getBlockState(localZ, y, localX);
// bedrock at the bottom
if (y <= rand.nextInt(5))
{
primer.setBlockState(localZ, y, localX, Blocks.BEDROCK.getDefaultState());
continue;
}
if (state.getMaterial() == Material.AIR)
{
// topBlocks and dirtBlocks can occur after any pocket of air
topBlocksToFill = (topBlock == null ? 0 : 1);
dirtBlocksToFill = dirtDepth;
continue;
}
else if (!hitFloorYet && state.getMaterial() == Material.WATER)
{
// seaFloorBlocks can occur after surface water
seaFloorBlocksToFill = seaFloorDepth;
}
if (state.getBlock() == Blocks.STONE)
{
hitFloorYet = true;
if (topBlocksToFill > 0)
{
if (y >= 62)
{
primer.setBlockState(localZ, y, localX, topBlock);
}
else if (y >= 56 - dirtDepth)
{
primer.setBlockState(localZ, y, localX, fillerBlock);
}
else
{
primer.setBlockState(localZ, y, localX, Blocks.GRAVEL.getDefaultState());
dirtBlocksToFill = 0;
}
topBlocksToFill--;
}
else if (seaFloorBlocksToFill > 0)
{
primer.setBlockState(localZ, y, localX, seaFloorBlock);
--seaFloorBlocksToFill;
}
else if (dirtBlocksToFill > 0)
{
primer.setBlockState(localZ, y, localX, fillerBlock);
--dirtBlocksToFill;
// add sandstone after a patch of sand
if (dirtBlocksToFill == 0 && fillerBlock.getBlock() == Blocks.SAND)
{
dirtBlocksToFill = rand.nextInt(4) + Math.max(0, y - 63);
fillerBlock = fillerBlock.getValue(BlockSand.VARIANT) == BlockSand.EnumType.RED_SAND ? Blocks.RED_SANDSTONE.getDefaultState() : Blocks.SANDSTONE.getDefaultState();
}
if (dirtBlocksToFill == 0 && fillerBlock.getBlock() == BOPBlocks.white_sand)
{
dirtBlocksToFill = rand.nextInt(4) + Math.max(0, y - 63);
fillerBlock = BOPBlocks.white_sandstone.getDefaultState();
}
}
}
}
}
@Override
public ResourceLocation getBeachLocation()
{
return this.beachBiomeLocation;
}
// the below two methods convert between our values and Vanilla.
// they're mostly used for mods like Pioneer rather than us.
@Override
public float getBaseHeight()
{
return ((float)this.terrainSettings.avgHeight - 65.0F) / 17.0F;
}
@Override
public float getHeightVariation()
{
// average the heightVariation values for above and below
return Math.abs((((float)this.terrainSettings.variationAbove - 7.0F) / (20.0F * 4.0F) + ((float)this.terrainSettings.variationBelow - 4.0F) / 20.0F) / 2.0F);
}
}

View File

@ -0,0 +1,95 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.BiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.feature.Features;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilders;
import net.minecraft.world.gen.surfacebuilders.SurfaceBuilder;
public class BambooBlossomGroveBiome extends BiomeTemplate
{
public BambooBlossomGroveBiome()
{
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.RAIN).biomeCategory(Biome.Category.FOREST).depth(0.05F).scale(0.05F).temperature(0.6F).downfall(0.9F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(4159204).waterFogColor(329011).fogColor(12638463).skyColor(calculateSkyColor(0.6F)).grassColorOverride(0x85CE71).foliageColorOverride(0x63BF66).ambientMoodSound(MoodSoundAmbience.LEGACY_CAVE_SETTINGS).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(ConfiguredSurfaceBuilders.GRASS);
// Structures
DefaultBiomeFeatures.addDefaultOverworldLandStructures(builder);
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_STANDARD);
// Underground
DefaultBiomeFeatures.addDefaultCarvers(builder);
DefaultBiomeFeatures.addDefaultLakes(builder);
DefaultBiomeFeatures.addDefaultMonsterRoom(builder);
DefaultBiomeFeatures.addDefaultUndergroundVariety(builder);
DefaultBiomeFeatures.addDefaultOres(builder);
////////////////////////////////////////////////////////////
// Vegetation
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.BAMBOO_BLOSSOM_GROVE_TREES);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.CHERRY_BLOSSOM_GROVE_FLOWERS);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.CLOVER_3);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.LILAC_2);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.LILY_PAD_5);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.SHORT_BAMBOO_5);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.STANDARD_GRASS_12);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.BROWN_MUSHROOM_NORMAL);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.PATCH_SUGAR_CANE);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.RED_MUSHROOM_NORMAL);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.SEAGRASS_COLD);
////////////////////////////////////////////////////////////
// Other Features
DefaultBiomeFeatures.addDefaultSprings(builder);
DefaultBiomeFeatures.addSurfaceFreezing(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
// Entities
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.SHEEP, 12, 4, 4));
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.PIG, 10, 4, 4));
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.CHICKEN, 10, 4, 4));
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.COW, 8, 4, 4));
builder.addSpawn(EntityClassification.CREATURE, new MobSpawnInfo.Spawners(EntityType.PANDA, 80, 1, 2));
builder.addSpawn(EntityClassification.AMBIENT, new MobSpawnInfo.Spawners(EntityType.BAT, 10, 8, 8));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SPIDER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE, 95, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE_VILLAGER, 5, 1, 1));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SKELETON, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.CREEPER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SLIME, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ENDERMAN, 10, 1, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.WITCH, 5, 1, 1));
}
}

View File

@ -0,0 +1,96 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.common.biome.BiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.feature.*;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilder;
import net.minecraft.world.gen.surfacebuilders.ConfiguredSurfaceBuilders;
import net.minecraft.world.gen.surfacebuilders.SurfaceBuilder;
public class BayouBiome extends BiomeTemplate
{
public BayouBiome()
{
this.addWeight(BOPClimates.SUBTROPICAL, 10);
this.setBeachBiome(BOPBiomes.bayou_mangrove);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.RAIN).biomeCategory(Biome.Category.SWAMP).depth(-0.3F).scale(0.0F).temperature(0.95F).downfall(0.9F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(0x62AF84).waterFogColor(0x0C211C).fogColor(12638463).skyColor(calculateSkyColor(0.95F)).grassColorOverride(0x6FAA50).foliageColorOverride(0x8BDB67).ambientMoodSound(MoodSoundAmbience.LEGACY_CAVE_SETTINGS).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(ConfiguredSurfaceBuilders.GRASS);
// Structures
DefaultBiomeFeatures.addDefaultOverworldLandStructures(builder);
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_SWAMP);
// Underground
DefaultBiomeFeatures.addDefaultCarvers(builder);
DefaultBiomeFeatures.addDefaultLakes(builder);
DefaultBiomeFeatures.addDefaultMonsterRoom(builder);
DefaultBiomeFeatures.addDefaultUndergroundVariety(builder);
DefaultBiomeFeatures.addDefaultOres(builder);
DefaultBiomeFeatures.addSwampClayDisk(builder);
builder.addFeature(GenerationStage.Decoration.UNDERGROUND_ORES, BOPConfiguredFeatures.MUD_DISK);
////////////////////////////////////////////////////////////
// Vegetation
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.BAYOU_TREES);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.CATTAIL_6);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.FERN_GRASS_8);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.LARGE_FERN_7);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.LILY_PAD_10);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.TALL_GRASS_6);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.BROWN_MUSHROOM_NORMAL);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.PATCH_SUGAR_CANE);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.RED_MUSHROOM_NORMAL);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.SEAGRASS_SWAMP);
////////////////////////////////////////////////////////////
// Other Features
DefaultBiomeFeatures.addDefaultSprings(builder);
DefaultBiomeFeatures.addSurfaceFreezing(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
// Entities
builder.addSpawn(EntityClassification.AMBIENT, new MobSpawnInfo.Spawners(EntityType.BAT, 10, 8, 8));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SPIDER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE, 95, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE_VILLAGER, 5, 1, 1));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SKELETON, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.CREEPER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SLIME, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ENDERMAN, 10, 1, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.WITCH, 5, 1, 1));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SLIME, 1, 1, 1));
}
}

View File

@ -0,0 +1,86 @@
/*******************************************************************************
* Copyright 2014-2019, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.common.biome.BiomeTemplate;
import biomesoplenty.common.world.gen.feature.BOPConfiguredFeatures;
import biomesoplenty.common.world.gen.surfacebuilders.BOPConfiguredSurfaceBuilders;
import net.minecraft.entity.EntityClassification;
import net.minecraft.entity.EntityType;
import net.minecraft.world.biome.*;
import net.minecraft.world.gen.GenerationStage;
import net.minecraft.world.gen.feature.Features;
import net.minecraft.world.gen.feature.structure.StructureFeatures;
public class BayouMangroveBiome extends BiomeTemplate
{
public BayouMangroveBiome()
{
this.setBeachBiome(null);
}
@Override
protected void configureBiome(Biome.Builder builder)
{
builder.precipitation(Biome.RainType.RAIN).biomeCategory(Biome.Category.SWAMP).depth(-0.175F).scale(-0.075F).temperature(0.95F).downfall(0.9F);
builder.specialEffects((new BiomeAmbience.Builder()).waterColor(0x62AF84).waterFogColor(0x0C211C).fogColor(12638463).skyColor(calculateSkyColor(0.95F)).grassColorOverride(0x6FAA50).foliageColorOverride(0x8BDB67).ambientMoodSound(MoodSoundAmbience.LEGACY_CAVE_SETTINGS).build());
}
@Override
protected void configureGeneration(BiomeGenerationSettings.Builder builder)
{
builder.surfaceBuilder(BOPConfiguredSurfaceBuilders.MANGROVE);
// Structures
DefaultBiomeFeatures.addDefaultOverworldLandStructures(builder);
builder.addStructureStart(StructureFeatures.RUINED_PORTAL_SWAMP);
// Underground
DefaultBiomeFeatures.addDefaultCarvers(builder);
DefaultBiomeFeatures.addDefaultLakes(builder);
builder.addFeature(GenerationStage.Decoration.LAKES, BOPConfiguredFeatures.WATER_LAKE_COMMON);
DefaultBiomeFeatures.addDefaultMonsterRoom(builder);
DefaultBiomeFeatures.addDefaultUndergroundVariety(builder);
DefaultBiomeFeatures.addDefaultOres(builder);
////////////////////////////////////////////////////////////
// Vegetation
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.MANGROVE_ROOTS);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.SPROUTS_75);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, BOPConfiguredFeatures.STANDARD_GRASS_12);
builder.addFeature(GenerationStage.Decoration.VEGETAL_DECORATION, Features.SEAGRASS_RIVER);
////////////////////////////////////////////////////////////
// Other Features
DefaultBiomeFeatures.addDefaultSprings(builder);
DefaultBiomeFeatures.addSurfaceFreezing(builder);
}
@Override
protected void configureMobSpawns(MobSpawnInfo.Builder builder)
{
// Entities
builder.addSpawn(EntityClassification.WATER_AMBIENT, new MobSpawnInfo.Spawners(EntityType.COD, 10, 3, 6));
builder.addSpawn(EntityClassification.WATER_AMBIENT, new MobSpawnInfo.Spawners(EntityType.TROPICAL_FISH, 5, 8, 8));
builder.addSpawn(EntityClassification.WATER_CREATURE, new MobSpawnInfo.Spawners(EntityType.SQUID, 5, 4, 4));
builder.addSpawn(EntityClassification.AMBIENT, new MobSpawnInfo.Spawners(EntityType.BAT, 10, 8, 8));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SPIDER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE, 95, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ZOMBIE_VILLAGER, 5, 1, 1));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SKELETON, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.CREEPER, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.SLIME, 100, 4, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.ENDERMAN, 10, 1, 4));
builder.addSpawn(EntityClassification.MONSTER, new MobSpawnInfo.Spawners(EntityType.WITCH, 5, 1, 1));
}
}

View File

@ -1,93 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import com.google.common.base.CaseFormat;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorLakes;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorTaigaTree;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.passive.EntityLlama;
import net.minecraft.init.Blocks;
public class BiomeGenAlps extends BOPOverworldBiome
{
public enum AlpsType {ALPS, ALPS_FOOTHILLS}
public AlpsType type;
public BiomeGenAlps(AlpsType type)
{
super(type.name().toLowerCase(), new PropsBuilder(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, type.toString())).withGuiColour(13421772).withSnowEnabled().withTemperature(-0.25F).withRainfall(0.3F));
this.type = type;
// terrain
switch (type)
{
case ALPS:
this.terrainSettings.avgHeight(198).heightVariation(12, 12).octaves(1, 1, 2, 2, 3, 3);
this.topBlock = Blocks.SNOW.getDefaultState();
this.fillerBlock = Blocks.SNOW.getDefaultState();
break;
case ALPS_FOOTHILLS:
this.terrainSettings.avgHeight(120).heightVariation(48, 64).octaves(0, 1, 1, 3, 1, 0);
this.hasBiomeEssence = false;
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.OVERGROWN_STONE);
this.fillerBlock = Blocks.STONE.getDefaultState();
break;
}
this.canGenerateRivers = false;
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
this.beachBiomeLocation = null;
if (type == AlpsType.ALPS)
{
this.addWeight(BOPClimates.TUNDRA, 3);
this.addWeight(BOPClimates.ICE_CAP, 5);
}
this.avgDirtDepth = 8;
this.spawnableCreatureList.clear();
// trees & logs
if (type == AlpsType.ALPS_FOOTHILLS)
{
this.spawnableCreatureList.add(new SpawnListEntry(EntityLlama.class, 5, 4, 6));
IBlockPosQuery emptyStone = BlockQuery.buildAnd().withAirAbove().states(BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.OVERGROWN_STONE)).create();
GeneratorWeighted treeGenerator = new GeneratorWeighted(0.5F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("fir", 1, (new GeneratorTaigaTree.Builder()).placeOn(emptyStone).log(BOPWoods.FIR).leaves(BOPTrees.FIR).minHeight(10).maxHeight(19).create());
// hot springs
this.addGenerator("hot_springs", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(0.5F).liquid(BOPBlocks.hot_spring_water).frozenLiquid((IBlockState)null).scatterYMethod(ScatterYMethod.AT_SURFACE).create());
}
// gem
this.addGenerator("emeralds", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(Blocks.EMERALD_ORE.getDefaultState()).create());
}
}

View File

@ -1,129 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPPlant;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBulbTree;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.block.BlockDirt;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.passive.EntityOcelot;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.chunk.ChunkPrimer;
public class BiomeGenBambooForest extends BOPOverworldBiome
{
public IBlockState usualTopBlock;
public IBlockState alternateTopBlock;
public BiomeGenBambooForest()
{
super("bamboo_forest", new PropsBuilder("Bamboo Forest").withGuiColour(0xA3E053).withRainfall(0.85F).withTemperature(0.9F));
// terrain
this.terrainSettings.avgHeight(68).heightVariation(5, 10);
this.canGenerateVillages = false;
this.addWeight(BOPClimates.TROPICAL, 3);
this.spawnableCreatureList.clear();
this.spawnableMonsterList.add(new SpawnListEntry(EntityOcelot.class, 2, 1, 1));
this.topBlock = Blocks.DIRT.getDefaultState().withProperty(BlockDirt.VARIANT, BlockDirt.DirtType.PODZOL);
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = Blocks.GRASS.getDefaultState();
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(0.5F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(30);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("bamboo", 3, (new GeneratorBulbTree.Builder()).minHeight(10).maxHeight(20).log(BOPBlocks.bamboo.getDefaultState()).leaves(BOPTrees.BAMBOO).create());
treeGenerator.add("bamboo_thin", 1, (new GeneratorTwigletTree.Builder()).minHeight(5).maxHeight(10).leafChance(0.3F).log(BOPBlocks.bamboo.getDefaultState()).leaves(BOPTrees.BAMBOO).create());
//treeGenerator.add("oak_bush", 1, (new GeneratorBush.Builder()).maxHeight(2).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(2.6F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("tallgrass", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("doublegrass", 2, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.GRASS).create());
// other plants
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(3.0F).placeOn(BlockQueries.fertile).with(BOPPlants.LEAFPILE).create());
this.addGenerator("ferns", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(4.0F).with(BlockTallGrass.EnumType.FERN).create());
this.addGenerator("river_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(5.0F).generationAttempts(24).placeOn(BlockQueries.litFertileWaterside).with(BlockBOPPlant.paging.getVariantState(BOPPlants.RIVERCANE)).minHeight(1).maxHeight(3).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(4.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.BUSH).create());
// gem
this.addGenerator("topaz", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TOPAZ).create());
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = conf.getBlockState("alternateTopBlock", this.alternateTopBlock);
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double noise)
{
this.topBlock = (noise + rand.nextDouble() * 3.0D > 1.8D) ? this.alternateTopBlock : this.usualTopBlock;
super.genTerrainBlocks(world, rand, primer, x, z, noise);
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xBBDD54);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xBBDD54);
}
}

View File

@ -1,136 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPLilypad;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorSplatter;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBayouTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.entity.monster.EntitySlime;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenFossils;
public class BiomeGenBayou extends BOPOverworldBiome
{
public BiomeGenBayou()
{
super("bayou", new PropsBuilder("Bayou").withGuiColour(0x7DAD51).withTemperature(0.95F).withRainfall(0.9F).withWaterColor(0xFFD932));
// terrain
this.terrainSettings.avgHeight(62).heightVariation(6, 3).octaves(1, 1, 1, 1, 0, 0).sidewaysNoise(0.0F);
//this.skyColor = 0xACC4BC;
this.seaFloorBlock = BOPBlocks.mud.getDefaultState();
this.canSpawnInBiome = false;
this.canGenerateRivers = false;
this.canGenerateVillages = false;
this.beachBiomeLocation = null;
this.addWeight(BOPClimates.HOT_SWAMP, 10);
this.spawnableMonsterList.add(new SpawnListEntry(EntitySlime.class, 10, 1, 3));
// mud
IBlockPosQuery emptyGrassOrDirt = BlockQuery.buildAnd().withAirAbove().states(this.topBlock, this.fillerBlock).create();
this.addGenerator("mud", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(1).maxRadius(3).with(BOPBlocks.mud.getDefaultState()).create());
this.addGenerator("mud_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(0.2F).replace(emptyGrassOrDirt).with(BOPBlocks.mud.getDefaultState()).create());
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(8);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("willow", 3, (new GeneratorBayouTree.Builder()).log(BOPWoods.WILLOW).leaves(BOPTrees.WILLOW).minHeight(6).maxHeight(12).minLeavesRadius(1).leavesGradient(2).create());
treeGenerator.add("willow_large", 1, (new GeneratorBayouTree.Builder()).log(BOPWoods.WILLOW).leaves(BOPTrees.WILLOW).minHeight(10).maxHeight(18).minLeavesRadius(2).leavesGradient(3).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(2.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("doublegrass", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.GRASS).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BOPPlants.KORU).create());
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(6.0F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(8.0F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("sugar_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(3.0F).generationAttempts(24).placeOn(BlockQueries.litFertileWaterside).with(Blocks.REEDS.getDefaultState()).minHeight(1).maxHeight(3).create());
// water plants
this.addGenerator("lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(2.5F).with(Blocks.WATERLILY.getDefaultState()).create());
this.addGenerator("medium_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(2.0F).with(BlockBOPLilypad.LilypadType.MEDIUM).create());
this.addGenerator("flower_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BlockBOPLilypad.LilypadType.FLOWER).create());
this.addGenerator("small_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(1.5F).with(BlockBOPLilypad.LilypadType.SMALL).create());
this.addGenerator("tiny_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(1.5F).with(BlockBOPLilypad.LilypadType.TINY).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(4.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.8F).with(BOPPlants.REED).generationAttempts(32).create());
// shrooms
this.addGenerator("flat_mushroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).generationAttempts(16).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).generationAttempts(16).with(Blocks.BROWN_MUSHROOM.getDefaultState()).create());
// gem
this.addGenerator("malachite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.MALACHITE).create());
}
@Override
public void decorate(World worldIn, Random rand, BlockPos pos)
{
super.decorate(worldIn, rand, pos);
if(net.minecraftforge.event.terraingen.TerrainGen.decorate(worldIn, rand, pos, net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.FOSSIL))
if (rand.nextInt(64) == 0)
{
(new WorldGenFossils()).generate(worldIn, rand, pos);
}
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x7DAD51);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0x9DDD66);
}
}

View File

@ -1,194 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.block.BlockBOPPlant;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorBigMushroom;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorLakes;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.monster.EntitySlime;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.chunk.ChunkPrimer;
import net.minecraft.world.gen.feature.WorldGenFossils;
public class BiomeGenBog extends BOPOverworldBiome
{
public IBlockState usualTopBlock;
public IBlockState alternateTopBlock;
public BiomeGenBog()
{
super("bog", new PropsBuilder("Bog").withGuiColour(0xD8935F).withTemperature(0.5F).withRainfall(0.9F).withWaterColor(0xBCFF96));
// terrain
this.terrainSettings.avgHeight(63).heightVariation(5, 1).octaves(1, 4, 3, 1, 1, 0);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.LOAMY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.LOAMY);
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.LOAMY).withProperty(BlockBOPDirt.COARSE, true);
this.seaFloorBlock = BOPBlocks.mud.getDefaultState();
this.canGenerateRivers = false;
this.canGenerateVillages = false;
if (BOPBiomes.gravel_beach.isPresent())
{
this.beachBiomeLocation = ((BOPOverworldBiome)BOPBiomes.gravel_beach.get()).getResourceLocation();
}
this.addWeight(BOPClimates.COLD_SWAMP, 7);
this.spawnableCreatureList.clear();
this.spawnableMonsterList.add(new SpawnListEntry(EntitySlime.class, 10, 1, 3));
// lakes
this.addGenerator("lakes", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(1.0F).waterLakeForBiome(this).create());
this.addGenerator("poison_lakes", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(0.1F).liquid(BOPBlocks.poison).frozenLiquid((IBlockState)null).create());
// mud
this.addGenerator("mud", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(4).maxRadius(7).with(BOPBlocks.mud.getDefaultState()).create());
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(2);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("oak_tree", 1, (new GeneratorBigTree.Builder()).foliageHeight(1).maxHeight(15).create());
treeGenerator.add("dark_oak_twiglet", 5, (new GeneratorTwigletTree.Builder()).log(BlockPlanks.EnumType.DARK_OAK).leaves(BlockPlanks.EnumType.DARK_OAK).minHeight(1).maxHeight(4).leafChance(0.3F, 0.9F).create());
treeGenerator.add("oak_twiglet", 6, (new GeneratorTwigletTree.Builder()).minHeight(2).maxHeight(5).leafChance(0.3F, 0.9F).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(0.75F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("tallgrass", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.KORU).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(3.0F).with(BOPPlants.BUSH).create());
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).with(BOPPlants.SHRUB).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).placeOn(BlockQueries.fertile).with(BOPPlants.LEAFPILE).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).placeOn(BlockQueries.fertile).with(BOPPlants.DEADLEAFPILE).create());
this.addGenerator("poison_ivy", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BOPPlants.POISONIVY).create());
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.1F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.REED).generationAttempts(32).create());
// shrooms
this.addGenerator("flat_mushroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.25F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).create());
this.addGenerator("blue_milk_caps", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.BLUE_MILK_CAP).create());
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(2.0F).generationAttempts(16).with(Blocks.BROWN_MUSHROOM.getDefaultState()).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).generationAttempts(16).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.TOADSTOOL).create());
this.addGenerator("big_brown_mushroom", GeneratorStage.BIG_SHROOM,(new GeneratorBigMushroom.Builder()).amountPerChunk(0.2F).minHeight(4).maxHeight(5).mushroomType(GeneratorBigMushroom.BigMushroomType.BROWN).create());
// gem
this.addGenerator("malachite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.MALACHITE).create());
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = conf.getBlockState("alternateTopBlock", this.alternateTopBlock);
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double noise)
{
this.topBlock = (noise + rand.nextDouble() * 1.0D > 1.9D) ? this.alternateTopBlock : this.usualTopBlock;
double d0 = GRASS_COLOR_NOISE.getValue((double)x * 0.25D, (double)z * 0.25D);
if (d0 > 0.0D)
{
int i = x & 15;
int j = z & 15;
for (int k = 255; k >= 0; --k)
{
if (primer.getBlockState(j, k, i).getMaterial() != Material.AIR)
{
if (k == 62 && primer.getBlockState(j, k, i).getBlock() != Blocks.WATER)
{
primer.setBlockState(j, k, i, WATER);
}
break;
}
}
}
super.genTerrainBlocks(world, rand, primer, x, z, noise);
}
@Override
public void decorate(World worldIn, Random rand, BlockPos pos)
{
super.decorate(worldIn, rand, pos);
if(net.minecraftforge.event.terraingen.TerrainGen.decorate(worldIn, rand, pos, net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.FOSSIL))
if (rand.nextInt(64) == 0)
{
(new WorldGenFossils()).generate(worldIn, rand, pos);
}
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xC1997C);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0x9DAF60);
}
}

View File

@ -1,101 +0,0 @@
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBasicTree;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import biomesoplenty.common.world.generator.tree.GeneratorBush;
import biomesoplenty.common.world.generator.tree.GeneratorTaigaTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.entity.passive.EntityRabbit;
import net.minecraft.entity.passive.EntityWolf;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.biome.Biome;
public class BiomeGenBorealForest extends BOPOverworldBiome
{
public BiomeGenBorealForest()
{
super("boreal_forest", new PropsBuilder("Boreal Forest").withGuiColour(0x9FB771).withTemperature(0.3F).withRainfall(0.6F));
// terrain
this.terrainSettings.avgHeight(70).heightVariation(15, 30);
this.addWeight(BOPClimates.BOREAL, 5);
this.canGenerateVillages = false;
if (BOPBiomes.gravel_beach.isPresent())
{
this.beachBiomeLocation = ((BOPOverworldBiome)BOPBiomes.gravel_beach.get()).getResourceLocation();
}
this.spawnableCreatureList.add(new SpawnListEntry(EntityWolf.class, 5, 4, 4));
this.spawnableCreatureList.add(new SpawnListEntry(EntityRabbit.class, 4, 2, 3));
// sand and gravel
this.addGenerator("gravel", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(6).maxRadius(7).with(Blocks.GRAVEL.getDefaultState()).create());
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(8);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("oak", 3, (new GeneratorBasicTree.Builder()).create());
treeGenerator.add("yellow_autumn", 4, (new GeneratorBigTree.Builder()).log(BlockPlanks.EnumType.BIRCH).leaves(BOPTrees.YELLOW_AUTUMN).foliageHeight(2).maxHeight(13).create());
treeGenerator.add("spruce", 5, (new GeneratorTaigaTree.Builder()).minHeight(10).maxHeight(19).create()); // TODO: implement pine cones
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(1.75F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("fern", 4, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.FERN).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(0.2F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// other plants
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.SHRUB).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.75F).with(BOPPlants.BUSH).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).placeOn(BlockQueries.fertile).with(BOPPlants.DEADLEAFPILE).create());
this.addGenerator("poison_ivy", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BOPPlants.POISONIVY).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BOPPlants.REED).generationAttempts(32).create());
// gem
this.addGenerator("amber", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.AMBER).create());
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x9FB771);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xC9CE65);
}
}

View File

@ -1,106 +0,0 @@
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorLakes;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBasicTree;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.passive.EntityRabbit;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.gen.feature.WorldGenFossils;
public class BiomeGenBrushland extends BOPOverworldBiome
{
public BiomeGenBrushland()
{
super("brushland", new PropsBuilder("Brushland").withGuiColour(0xC6C19B).withTemperature(1.5F).withRainfall(0.1F).withRainDisabled());
// terrain
this.terrainSettings.avgHeight(66).heightVariation(3, 20);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.SANDY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.SANDY);
this.addWeight(BOPClimates.SAVANNA, 10);
this.canGenerateVillages = true;
this.spawnableCreatureList.add(new SpawnListEntry(EntityRabbit.class, 4, 2, 3));
//sand
this.addGenerator("sand", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(4).maxRadius(7).with(Blocks.SAND.getDefaultState()).create());
// quicksand
this.addGenerator("quicksand", GeneratorStage.SAND, (new GeneratorLakes.Builder()).amountPerChunk(0.2F).liquid(BOPBlocks.sand).frozenLiquid((IBlockState)null).create());
// trees & logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(6.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("brush", 1, (new GeneratorBasicTree.Builder()).log(BlockPlanks.EnumType.ACACIA).leaves(BlockPlanks.EnumType.ACACIA).minHeight(3).maxHeight(5).leafLayers(2).create());
treeGenerator.add("brush_twiglet", 2, (new GeneratorTwigletTree.Builder()).minHeight(1).maxHeight(2).log(BOPWoods.EBONY).leaves(BOPTrees.EBONY).create());
treeGenerator.add("jungle_twiglet", 1, (new GeneratorTwigletTree.Builder()).minHeight(2).maxHeight(2).log(BlockPlanks.EnumType.JUNGLE).leaves(BlockPlanks.EnumType.JUNGLE).trunkFruit(Blocks.COCOA.getDefaultState()).create());
treeGenerator.add("brush_bush", 3, (new GeneratorFlora.Builder()).placeOn(this.topBlock).replace(Material.AIR).withNonDecayingLeaf(BlockPlanks.EnumType.OAK).generationAttempts(8).create());
treeGenerator.add("decaying_tree", 2, (new GeneratorBigTree.Builder()).amountPerChunk(1.0F).log(BOPWoods.EBONY).leaves(BOPTrees.EBONY).minHeight(4).maxHeight(10).foliageHeight(1).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(9.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
// other plants
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BOPPlants.SHRUB).create());
this.addGenerator("thorns", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BOPPlants.THORN).create());
// gem
this.addGenerator("ruby", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.RUBY).create());
}
@Override
public void decorate(World worldIn, Random rand, BlockPos pos)
{
super.decorate(worldIn, rand, pos);
if(net.minecraftforge.event.terraingen.TerrainGen.decorate(worldIn, rand, pos, net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.FOSSIL))
if (rand.nextInt(64) == 0)
{
(new WorldGenFossils()).generate(worldIn, rand, pos);
}
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xC6C19B);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xB3BA73);
}
}

View File

@ -1,143 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorSplotches;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.passive.EntityDonkey;
import net.minecraft.entity.passive.EntityHorse;
import net.minecraft.entity.passive.EntityRabbit;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.chunk.ChunkPrimer;
public class BiomeGenChaparral extends BOPOverworldBiome
{
public IBlockState usualTopBlock;
public IBlockState usualFillerBlock;
public IBlockState alternateTopBlock;
public IBlockState alternateFillerBlock;
public BiomeGenChaparral()
{
super("chaparral", new PropsBuilder("Chaparral").withGuiColour(0xC4D675).withTemperature(0.8F).withRainfall(0.4F));
// terrain
this.terrainSettings.avgHeight(80).heightVariation(10, 20);
this.addWeight(BOPClimates.MEDITERANEAN, 10);
this.usualTopBlock = this.topBlock;
this.usualFillerBlock = this.fillerBlock;
this.alternateTopBlock = Blocks.STONE.getDefaultState();
this.alternateFillerBlock = Blocks.STONE.getDefaultState();
this.spawnableCreatureList.add(new SpawnListEntry(EntityHorse.class, 1, 2, 6));
this.spawnableCreatureList.add(new SpawnListEntry(EntityDonkey.class, 1, 1, 1));
this.spawnableCreatureList.add(new SpawnListEntry(EntityRabbit.class, 4, 2, 3));
this.canGenerateVillages = true;
// sand
this.addGenerator("sand", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(3).maxRadius(7).with(Blocks.SAND.getDefaultState()).create());
// stone patches
IBlockPosQuery emptyStoneOrGrass = BlockQuery.buildAnd().withAirAbove().states(this.topBlock, Blocks.STONE.getDefaultState()).create();
this.addGenerator("stone_patches", GeneratorStage.SAND, (new GeneratorSplotches.Builder()).amountPerChunk(4).splotchSize(15).replace(emptyStoneOrGrass).with(BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.OVERGROWN_STONE)).scatterYMethod(ScatterYMethod.AT_SURFACE).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(0.5F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("rose", 8, (new GeneratorDoubleFlora.Builder()).amountPerChunk(1).with(BlockDoublePlant.EnumPlantType.ROSE).create());
flowerGenerator.add("syringa", 4, (new GeneratorDoubleFlora.Builder()).amountPerChunk(1).with(BlockDoublePlant.EnumPlantType.SYRINGA).create());
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(1.5F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("wheatgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.WHEATGRASS).create());
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(7.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("twiglet", 3, (new GeneratorTwigletTree.Builder()).minHeight(2).maxHeight(2).log(BlockPlanks.EnumType.OAK).leaves(BlockPlanks.EnumType.OAK).create());
treeGenerator.add("small_bush", 1, (new GeneratorFlora.Builder()).placeOn(this.topBlock).replace(Material.AIR).withNonDecayingLeaf(BlockPlanks.EnumType.OAK).create());
// other plants
this.addGenerator("berry_bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.BERRYBUSH).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.75F).with(BOPPlants.BUSH).create());
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.SHRUB).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.0F).placeOn(BlockQueries.fertile).with(BOPPlants.LEAFPILE).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).placeOn(BlockQueries.fertile).with(BOPPlants.DEADLEAFPILE).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.REED).generationAttempts(32).create());
// gem
this.addGenerator("peridot", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.PERIDOT).create());
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
this.usualTopBlock = this.topBlock;
this.usualFillerBlock = this.fillerBlock;
this.alternateTopBlock = conf.getBlockState("alternateTopBlock", this.alternateTopBlock);
this.alternateFillerBlock = conf.getBlockState("alternateFillerBlock", this.alternateFillerBlock);
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double noise)
{
this.topBlock = (noise + rand.nextDouble() * 1.0D > 2.0D) ? this.alternateTopBlock : this.usualTopBlock;
this.fillerBlock = (noise + rand.nextDouble() * 1.0D > 2.0D) ? this.alternateFillerBlock : this.usualFillerBlock;
super.genTerrainBlocks(world, rand, primer, x, z, noise);
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xC4D675);
}
}

View File

@ -1,110 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPLilypad;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBasicTree;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
public class BiomeGenCherryBlossomGrove extends BOPOverworldBiome
{
public BiomeGenCherryBlossomGrove()
{
super("cherry_blossom_grove", new PropsBuilder("Cherry Blossom Grove").withGuiColour(0xF88F8F).withTemperature(0.55F).withRainfall(0.8F));
// terrain
this.terrainSettings.avgHeight(63).heightVariation(5, 25).sidewaysNoise(0.8F);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.SILTY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.SILTY);
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
this.addWeight(BOPClimates.COOL_TEMPERATE, 2);
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(2.3F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("pink_daffodil", 4, (new GeneratorFlora.Builder().with(BOPFlowers.PINK_DAFFODIL).create()));
flowerGenerator.add("white_anemones", 3, (new GeneratorFlora.Builder().with(BOPFlowers.WHITE_ANEMONE).create()));
flowerGenerator.add("clover", 2, (new GeneratorFlora.Builder().with(BOPFlowers.CLOVER).create()));
flowerGenerator.add("syringa", 2, (new GeneratorDoubleFlora.Builder().with(BlockDoublePlant.EnumPlantType.SYRINGA).create()));
flowerGenerator.add("houstonia", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.HOUSTONIA).create()));
flowerGenerator.add("oxeye_daisy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.OXEYE_DAISY).create()));
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(3.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("pink_cherry", 2, (new GeneratorBasicTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.PINK_CHERRY).create());
treeGenerator.add("white_cherry", 1, (new GeneratorBasicTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.WHITE_CHERRY).create());
treeGenerator.add("large_pink_cherry", 4, (new GeneratorBigTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.PINK_CHERRY).create());
treeGenerator.add("large_white_cherry", 3, (new GeneratorBigTree.Builder()).log(BOPWoods.CHERRY).leaves(BOPTrees.WHITE_CHERRY).create());
// other plants
this.addGenerator("flax", GeneratorStage.FLOWERS,(new GeneratorDoubleFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPDoublePlant.DoublePlantType.FLAX).generationAttempts(6).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).placeOn(BlockQueries.fertile).with(BOPPlants.LEAFPILE).create());
this.addGenerator("clover_patches", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).generationAttempts(128).with(BOPPlants.CLOVERPATCH).create());
this.addGenerator("sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).with(BOPPlants.SPROUT).create());
// water plants
this.addGenerator("lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(Blocks.WATERLILY.getDefaultState()).create());
this.addGenerator("medium_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BlockBOPLilypad.LilypadType.MEDIUM).create());
this.addGenerator("small_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BlockBOPLilypad.LilypadType.SMALL).create());
this.addGenerator("tiny_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPLilypad.LilypadType.TINY).create());
this.addGenerator("flower_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BlockBOPLilypad.LilypadType.FLOWER).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(1.6F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
// gem
this.addGenerator("topaz", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TOPAZ).create());
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x96EA9B);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xA3FFAA);
}
}

View File

@ -1,91 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.config.IConfigObj;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery.BlockQueryBlock;
import biomesoplenty.common.world.generator.GeneratorBlobs;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorSplatter;
import biomesoplenty.common.world.generator.GeneratorSplotches;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.monster.EntityPolarBear;
import net.minecraft.init.Blocks;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.chunk.ChunkPrimer;
public class BiomeGenColdDesert extends BOPOverworldBiome
{
public IBlockState usualTopBlock;
public IBlockState alternateTopBlock;
public BiomeGenColdDesert()
{
super("cold_desert", new PropsBuilder("Cold Desert").withGuiColour(0xB3AF9B).withTemperature(0.2F).withRainfall(0.0F));
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
if (BOPBiomes.gravel_beach.isPresent())
{
this.beachBiomeLocation = ((BOPOverworldBiome)BOPBiomes.gravel_beach.get()).getResourceLocation();
}
// terrain
this.terrainSettings.avgHeight(64).heightVariation(5, 10).sidewaysNoise(0.7D);
this.topBlock = Blocks.GRAVEL.getDefaultState();
this.fillerBlock = Blocks.STONE.getDefaultState();
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = Blocks.SNOW.getDefaultState();
this.canGenerateRivers = false;
this.addWeight(BOPClimates.ICE_CAP, 10);
this.spawnableCreatureList.clear();
this.spawnableCreatureList.add(new SpawnListEntry(EntityPolarBear.class, 1, 1, 2));
// gravel, stone and boulders
IBlockPosQuery surface = new BlockQueryBlock(Blocks.STONE, Blocks.GRAVEL);
this.addGenerator("stone_patches", GeneratorStage.SAND, (new GeneratorSplotches.Builder()).amountPerChunk(6).splotchSize(24).placeOn(surface).replace(surface).with(Blocks.STONE.getDefaultState()).scatterYMethod(ScatterYMethod.AT_SURFACE).create());
this.addGenerator("boulders", GeneratorStage.SAND_PASS2, (new GeneratorBlobs.Builder()).amountPerChunk(0.2F).placeOn(surface).with(Blocks.COBBLESTONE.getDefaultState()).minRadius(1.0F).maxRadius(3.0F).numBalls(4).scatterYMethod(ScatterYMethod.AT_SURFACE).create());
this.addGenerator("hard_ice_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(1.0F).replace(surface).with(BOPBlocks.hard_ice.getDefaultState()).create());
// gem
this.addGenerator("tanzanite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TANZANITE).create());
}
@Override
public void configure(IConfigObj conf)
{
super.configure(conf);
this.usualTopBlock = this.topBlock;
this.alternateTopBlock = conf.getBlockState("alternateTopBlock", this.alternateTopBlock);
}
@Override
public void genTerrainBlocks(World world, Random rand, ChunkPrimer primer, int x, int z, double noise)
{
this.topBlock = (noise + rand.nextDouble() * 3.0D > 1.8D) ? this.alternateTopBlock : this.usualTopBlock;
super.genTerrainBlocks(world, rand, primer, x, z, noise);
}
}

View File

@ -1,102 +0,0 @@
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorTaigaTree;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.entity.passive.EntityRabbit;
import net.minecraft.entity.passive.EntityWolf;
import net.minecraft.init.Blocks;
import net.minecraft.world.biome.Biome;
public class BiomeGenConiferousForest extends BOPOverworldBiome
{
public BiomeGenConiferousForest()
{
super("coniferous_forest", new PropsBuilder("Coniferous Forest").withGuiColour(0x528F60).withTemperature(0.45F).withRainfall(0.5F));
// terrain
this.terrainSettings.avgHeight(68).heightVariation(10, 20);
this.canGenerateVillages = true;
if (BOPBiomes.gravel_beach.isPresent())
{
this.beachBiomeLocation = ((BOPOverworldBiome)BOPBiomes.gravel_beach.get()).getResourceLocation();
}
this.addWeight(BOPClimates.BOREAL, 10);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.LOAMY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.LOAMY);
this.spawnableCreatureList.add(new SpawnListEntry(EntityWolf.class, 8, 4, 4));
this.spawnableCreatureList.add(new SpawnListEntry(EntityRabbit.class, 4, 2, 3));
// gravel
this.addGenerator("gravel", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(4).maxRadius(7).with(Blocks.GRAVEL.getDefaultState()).create());
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(8.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("fir", 5, (new GeneratorTaigaTree.Builder()).log(BOPWoods.FIR).leaves(BOPTrees.FIR).minHeight(5).maxHeight(28).create());
treeGenerator.add("mega_fir", 3, (new GeneratorTaigaTree.Builder()).log(BOPWoods.FIR).leaves(BOPTrees.FIR).minHeight(20).maxHeight(40).trunkWidth(2).create());
// other plants
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.SHRUB).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.7F).placeOn(BlockQueries.fertile).with(BOPPlants.DEADLEAFPILE).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).placeOn(BlockQueries.fertile).with(BOPPlants.LEAFPILE).generationAttempts(64).create());
this.addGenerator("flax", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.1F).with(BlockBOPDoublePlant.DoublePlantType.FLAX).create());
this.addGenerator("poison_ivy", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BOPPlants.POISONIVY).create());
// shrooms
this.addGenerator("flat_mushroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).create());
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.3F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.TOADSTOOL).create());
this.addGenerator("blue_milk_caps", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.BLUE_MILK_CAP).create());
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).generationAttempts(16).with(Blocks.BROWN_MUSHROOM.getDefaultState()).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.8F).with(BOPPlants.REED).generationAttempts(32).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(0.3F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("bluebells", 1, (new GeneratorFlora.Builder().with(BOPFlowers.BLUEBELLS)).generationAttempts(128).create());
flowerGenerator.add("oxeye_daisy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.OXEYE_DAISY).create()));
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(1.7F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("tallgrass", 4, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).generationAttempts(128).create());
grassGenerator.add("shortgrass", 3, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 3, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
grassGenerator.add("fern", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.FERN).create());
// gem
this.addGenerator("amber", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.AMBER).create());
}
}

View File

@ -1,51 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.util.biome.BiomeUtils;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import net.minecraft.init.Biomes;
import net.minecraft.init.Blocks;
public class BiomeGenCoralReef extends BOPOverworldBiome
{
public BiomeGenCoralReef()
{
super("coral_reef", new PropsBuilder("Coral Reef").withGuiColour(18285));
// terrain
this.terrainSettings.avgHeight(45).heightVariation(5, 10);
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
this.canGenerateRivers = false;
this.hasBiomeEssence = false;
this.beachBiomeLocation = BiomeUtils.getLocForBiome(Biomes.OCEAN);
clearWeights();
// coral
this.addGenerator("pink_coral", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(15.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.PINK)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("orange_coral", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(15.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ORANGE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("blue_coral", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(15.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.BLUE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("glowing_coral", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(15.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.GLOWING)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(3.0F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
// gem
this.addGenerator("sapphire", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.SAPPHIRE).create());
}
}

View File

@ -1,67 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorSplatter;
import biomesoplenty.common.world.generator.GeneratorSplotches;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
public class BiomeGenCrag extends BOPOverworldBiome
{
public BiomeGenCrag()
{
super("crag", new PropsBuilder("Crag").withGuiColour(5209457).withTemperature(0.5F).withRainfall(0.5F));
// terrain
this.terrainSettings.avgHeight(100).heightVariation(80, 200).minHeight(40).sidewaysNoise(0.7F);
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
this.canGenerateRivers = false;
this.beachBiomeLocation = null;
this.addWeight(BOPClimates.COLD_SWAMP, 2);
this.spawnableCreatureList.clear();
this.topBlock = Blocks.GRAVEL.getDefaultState();
this.fillerBlock = Blocks.STONE.getDefaultState();
// gravel, cobblestone, overgrown stone
IBlockPosQuery surface = BlockQuery.buildAnd().withAirAbove().states(this.topBlock).create();
this.addGenerator("overgrown_stone_patches", GeneratorStage.SAND, (new GeneratorSplotches.Builder()).amountPerChunk(24).splotchSize(16).placeOn(surface).replace(surface).with(BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.OVERGROWN_STONE)).scatterYMethod(ScatterYMethod.AT_SURFACE).create());
this.addGenerator("cobblestone_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(4.0F).replace(surface).with(Blocks.COBBLESTONE.getDefaultState()).create());
this.addGenerator("stone_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(4.0F).replace(surface).with(Blocks.STONE.getDefaultState()).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(4.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("tallgrass", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).generationAttempts(128).create());
grassGenerator.add("shortgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).generationAttempts(128).create());
// gem
this.addGenerator("emeralds", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(Blocks.EMERALD_ORE.getDefaultState()).create());
}
}

View File

@ -1,96 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBasicTree;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import biomesoplenty.common.world.generator.tree.GeneratorTaigaTree;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
public class BiomeGenDeadForest extends BOPOverworldBiome
{
public BiomeGenDeadForest()
{
super("dead_forest", new PropsBuilder("Dead Forest").withGuiColour(0xBCA165).withTemperature(0.3F).withRainfall(0.3F));
// terrain
this.terrainSettings.avgHeight(68).heightVariation(8, 25);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.LOAMY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.LOAMY);
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
if (BOPBiomes.gravel_beach.isPresent())
{
this.beachBiomeLocation = ((BOPOverworldBiome)BOPBiomes.gravel_beach.get()).getResourceLocation();
}
this.addWeight(BOPClimates.BOREAL, 3);
// gravel
this.addGenerator("gravel", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(4).maxRadius(7).with(Blocks.GRAVEL.getDefaultState()).create());
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(2.5F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("spruce", 3, (new GeneratorTaigaTree.Builder()).minHeight(6).maxHeight(16).create()); // TODO: implement pine cones
treeGenerator.add("dying_tree", 5, (new GeneratorBigTree.Builder()).minHeight(5).maxHeight(12).foliageHeight(2).leaves(BOPTrees.DEAD).create());
treeGenerator.add("oak", 3, (new GeneratorBasicTree.Builder()).leaves(BOPTrees.DEAD).create());
treeGenerator.add("dead_tree", 1, (new GeneratorBigTree.Builder()).minHeight(5).maxHeight(12).foliageHeight(0).foliageDensity(0.5D).log(BOPWoods.DEAD).leaves(Blocks.AIR.getDefaultState()).create());
// other plants
this.addGenerator("thorns", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BOPPlants.THORN).create());
//this.addGenerator("shrubs", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.SHRUB).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.8F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(3.5F).placeOn(BlockQueries.fertile).with(BOPPlants.DEADLEAFPILE).generationAttempts(64).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(1.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 4, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 3, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
grassGenerator.add("dead_bushes", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.DEAD_BUSH).create());
// gem
this.addGenerator("tanzanite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TANZANITE).create());
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xBCA165);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xBCA165);
}
}

View File

@ -1,119 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPPlant;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorSplotches;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenFossils;
public class BiomeGenDeadSwamp extends BOPOverworldBiome
{
public BiomeGenDeadSwamp()
{
super("dead_swamp", new PropsBuilder("Dead Swamp").withGuiColour(0x8BAF48).withTemperature(0.6F).withRainfall(0.9F).withWaterColor(0xA2AD51));
// terrain
this.terrainSettings.avgHeight(63).heightVariation(6, 3);
//this.skyColor = 0x627268;
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.LOAMY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.LOAMY);
this.seaFloorBlock = BOPBlocks.mud.getDefaultState();
this.canSpawnInBiome = false;
this.canGenerateRivers = false;
this.canGenerateVillages = false;
this.beachBiomeLocation = null;
this.addWeight(BOPClimates.COLD_SWAMP, 3);
this.spawnableCreatureList.clear();
// mud
this.addGenerator("mud", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(8).maxRadius(7).with(BOPBlocks.mud.getDefaultState()).create());
this.addGenerator("mud_patches", GeneratorStage.SAND_PASS2, (new GeneratorSplotches.Builder()).amountPerChunk(1).splotchSize(12).replace(this.topBlock).with(BOPBlocks.mud.getDefaultState()).scatterYMethod(ScatterYMethod.AT_SURFACE).create());
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(0.6F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("dying_tree", 3, (new GeneratorBigTree.Builder()).minHeight(5).maxHeight(12).foliageHeight(1).log(BOPWoods.DEAD).leaves(BOPTrees.DEAD).create());
treeGenerator.add("dead_tree", 1, (new GeneratorBigTree.Builder()).minHeight(5).maxHeight(12).foliageHeight(0).foliageDensity(0.5D).log(BOPWoods.DEAD).leaves(Blocks.AIR.getDefaultState()).create());
// other plants
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.KORU).create());
// water plants
this.addGenerator("river_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(0.3F).generationAttempts(24).placeOn(BlockQueries.litFertileWaterside).with(BlockBOPPlant.paging.getVariantState(BOPPlants.RIVERCANE)).minHeight(1).maxHeight(3).create());
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).generationAttempts(32).scatterYMethod(ScatterYMethod.AT_GROUND).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(1.4F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 4, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
// gem
this.addGenerator("malachite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.MALACHITE).create());
}
@Override
public void decorate(World worldIn, Random rand, BlockPos pos)
{
super.decorate(worldIn, rand, pos);
if(net.minecraftforge.event.terraingen.TerrainGen.decorate(worldIn, rand, pos, net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.FOSSIL))
if (rand.nextInt(64) == 0)
{
(new WorldGenFossils()).generate(worldIn, rand, pos);
}
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x66704C);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0x66704C);
}
}

View File

@ -1,193 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.config.IBOPWorldSettings;
import biomesoplenty.api.config.IBOPWorldSettings.GeneratorType;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.block.BlockBOPPlant;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorBigMushroom;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorMixedLily;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower.EnumFlowerType;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
// This class is not intended to be used in the game
// It just contains one of every common generator, so it can be used as a template when creating new biomes - just delete lines you don't want and adjust weightings
public class BiomeGenDummyTemplate extends BOPOverworldBiome
{
public BiomeGenDummyTemplate()
{
super(null, null);
// terrain
this.terrainSettings.avgHeight(64).heightVariation(6, 21).octaves(1, 1, 1, 1, 1, 1);
this.skyColor = 0xFFFFFF;
this.addWeight(BOPClimates.COOL_TEMPERATE, 10);
// gravel
this.addGenerator("gravel", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(4).maxRadius(7).with(Blocks.GRAVEL.getDefaultState()).create());
// mud
this.addGenerator("mud", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(3).maxRadius(7).with(BOPBlocks.mud.getDefaultState()).create());
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(9);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
// TODO: standard trees here? Is there such a thing as standard trees?
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(2.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("deadgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DEADGRASS).create());
grassGenerator.add("desertgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DESERTGRASS).create());
grassGenerator.add("dunegrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DUNEGRASS).create());
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
grassGenerator.add("tallgrass", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("ferns", 1, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.FERN).create());
grassGenerator.add("wheatgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.WHEATGRASS).create());
grassGenerator.add("dampgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("doublegrass", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.GRASS).create());
// other plants
this.addGenerator("berry_bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.BERRYBUSH).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.BUSH).create());
this.addGenerator("cattails", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.CATTAIL).create());
this.addGenerator("clover_patches", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.CLOVERPATCH).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.DEADLEAFPILE).create());
this.addGenerator("desert_sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.DESERTSPROUTS).create());
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.KORU).create());
this.addGenerator("leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.LEAFPILE).create());
this.addGenerator("poison_ivy", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.POISONIVY).create());
this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.SHRUB).create());
this.addGenerator("spectral_ferns", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.SPECTRALFERN).create());
this.addGenerator("sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.SPROUT).create());
this.addGenerator("thorns", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.THORN).create());
this.addGenerator("tiny_cacti", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.TINYCACTUS).create());
this.addGenerator("wild_rice", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.WILDRICE).create());
this.addGenerator("dead_bushes", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BlockTallGrass.EnumType.DEAD_BUSH).create());
this.addGenerator("eyebulbs", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.5F).with(BlockBOPDoublePlant.DoublePlantType.EYEBULB).create());
this.addGenerator("flax", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.5F).with(BlockBOPDoublePlant.DoublePlantType.FLAX).create());
this.addGenerator("tall_cattails", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.5F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("tall_ferns", GeneratorStage.FLOWERS, (new GeneratorDoubleFlora.Builder()).amountPerChunk(0.5F).with(BlockDoublePlant.EnumPlantType.FERN).create());
this.addGenerator("river_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(0.5F).placeOn(BlockQueries.litFertileWaterside).with(BlockBOPPlant.paging.getVariantState(BOPPlants.RIVERCANE)).minHeight(1).maxHeight(3).create());
this.addGenerator("sugar_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(0.5F).placeOn(BlockQueries.litFertileWaterside).with(Blocks.REEDS.getDefaultState()).minHeight(1).maxHeight(3).create());
// TODO root
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("mixed_lily", GeneratorStage.LILYPAD, (new GeneratorMixedLily.Builder()).amountPerChunk(0.5F).create());
this.addGenerator("algae", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).replace(Blocks.WATER).with(BOPBlocks.coral.getDefaultState().withProperty(BlockBOPCoral.VARIANT, BlockBOPCoral.CoralType.ALGAE)).scatterYMethod(ScatterYMethod.AT_GROUND).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(1.0F);
this.addGenerator("flowers", GeneratorStage.GRASS, flowerGenerator);
flowerGenerator.add("alliums", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.ALLIUM).create()));
flowerGenerator.add("blue_orchids", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.BLUE_ORCHID).create()));
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.DANDELION).create()));
flowerGenerator.add("houstonias", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.HOUSTONIA).create()));
flowerGenerator.add("orange_tulips", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.ORANGE_TULIP).create()));
flowerGenerator.add("oxeye_daisies", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.OXEYE_DAISY).create()));
flowerGenerator.add("pink_tulips", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.PINK_TULIP).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.POPPY).create()));
flowerGenerator.add("red_tulips", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.RED_TULIP).create()));
flowerGenerator.add("white_tulips", 1, (new GeneratorFlora.Builder().with(EnumFlowerType.WHITE_TULIP).create()));
flowerGenerator.add("blue_hydrangeas", 1, (new GeneratorFlora.Builder().with(BOPFlowers.BLUE_HYDRANGEA).create()));
flowerGenerator.add("bluebells", 1, (new GeneratorFlora.Builder().with(BOPFlowers.BLUEBELLS).create()));
flowerGenerator.add("bromeliads", 1, (new GeneratorFlora.Builder().with(BOPFlowers.BROMELIAD).create()));
flowerGenerator.add("burning_blossoms", 1, (new GeneratorFlora.Builder().with(BOPFlowers.BURNING_BLOSSOM).create()));
flowerGenerator.add("clover", 1, (new GeneratorFlora.Builder().with(BOPFlowers.CLOVER).create()));
flowerGenerator.add("wilted_lily", 1, (new GeneratorFlora.Builder().with(BOPFlowers.WILTED_LILY).create()));
flowerGenerator.add("deathbloom", 1, (new GeneratorFlora.Builder().with(BOPFlowers.DEATHBLOOM).create()));
flowerGenerator.add("enterlotus", 1, (new GeneratorFlora.Builder().with(BOPFlowers.ENDERLOTUS).create()));
flowerGenerator.add("glowflower", 1, (new GeneratorFlora.Builder().with(BOPFlowers.GLOWFLOWER).create()));
flowerGenerator.add("goldenrods", 1, (new GeneratorFlora.Builder().with(BOPFlowers.GOLDENROD).create()));
flowerGenerator.add("icy_irises", 1, (new GeneratorFlora.Builder().with(BOPFlowers.ICY_IRIS).create()));
flowerGenerator.add("lavender", 1, (new GeneratorFlora.Builder().with(BOPFlowers.LAVENDER).create()));
flowerGenerator.add("lily_of_the_valley", 1, (new GeneratorFlora.Builder().with(BOPFlowers.LILY_OF_THE_VALLEY).create()));
flowerGenerator.add("miners_delight", 1, (new GeneratorFlora.Builder().with(BOPFlowers.MINERS_DELIGHT).create()));
flowerGenerator.add("orange_cosmos", 1, (new GeneratorFlora.Builder().with(BOPFlowers.ORANGE_COSMOS).create()));
flowerGenerator.add("pink_daffodil", 1, (new GeneratorFlora.Builder().with(BOPFlowers.PINK_DAFFODIL).create()));
flowerGenerator.add("hibiscus", 1, (new GeneratorFlora.Builder().with(BOPFlowers.PINK_HIBISCUS).create()));
flowerGenerator.add("roses", 1, (new GeneratorFlora.Builder().with(BOPFlowers.ROSE).create()));
flowerGenerator.add("swampflower", 1, (new GeneratorFlora.Builder().with(BOPFlowers.SWAMPFLOWER).create()));
flowerGenerator.add("violet", 1, (new GeneratorFlora.Builder().with(BOPFlowers.VIOLET).create()));
flowerGenerator.add("white_anemones", 1, (new GeneratorFlora.Builder().with(BOPFlowers.WHITE_ANEMONE).create()));
flowerGenerator.add("wildflowers", 1, (new GeneratorFlora.Builder().with(BOPFlowers.WILDFLOWER).create()));
flowerGenerator.add("paeonias", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.PAEONIA).create());
flowerGenerator.add("tall_roses", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.ROSE).create());
flowerGenerator.add("sunflowers", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.SUNFLOWER).create());
flowerGenerator.add("syringas", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.SYRINGA).create());
// shrooms
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(Blocks.BROWN_MUSHROOM.getDefaultState()).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
this.addGenerator("blue_milk_caps", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPMushroom.MushroomType.BLUE_MILK_CAP).create());
this.addGenerator("flat_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).create());
this.addGenerator("glowshrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPMushroom.MushroomType.GLOWSHROOM).create());
this.addGenerator("portobellos", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPMushroom.MushroomType.PORTOBELLO).create());
this.addGenerator("shadow_shrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPMushroom.MushroomType.SHADOW_SHROOM).create());
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BlockBOPMushroom.MushroomType.TOADSTOOL).create());
// big mushrooms
GeneratorWeighted mushroomGenerator = new GeneratorWeighted(0.5F);
this.addGenerator("big_mushrooms", GeneratorStage.BIG_SHROOM, mushroomGenerator);
mushroomGenerator.add("brown_mushroom", 1, (new GeneratorBigMushroom.Builder()).mushroomType(GeneratorBigMushroom.BigMushroomType.BROWN).create());
mushroomGenerator.add("red_mushroom", 1, (new GeneratorBigMushroom.Builder()).mushroomType(GeneratorBigMushroom.BigMushroomType.RED).create());
// gem
this.addGenerator("amber", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.AMBER).create());
}
@Override
public void applySettings(IBOPWorldSettings settings)
{
if (!settings.isEnabled(GeneratorType.GEMS)) {this.removeGenerator("amber");}
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xFFFFFF);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xFFFFFF);
}
}

View File

@ -1,84 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPLilypad;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBulbTree;
import biomesoplenty.common.world.generator.tree.GeneratorBush;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.entity.passive.EntityOcelot;
import net.minecraft.entity.passive.EntityParrot;
import net.minecraft.init.Blocks;
public class BiomeGenEucalyptusForest extends BOPOverworldBiome
{
public BiomeGenEucalyptusForest()
{
super("eucalyptus_forest", new PropsBuilder("Eucalyptus Forest").withGuiColour(0x9DCC70).withTemperature(0.95F).withRainfall(0.9F));
// terrain
this.terrainSettings.avgHeight(64).heightVariation(10, 20);
this.canGenerateVillages = false;
this.addWeight(BOPClimates.TROPICAL, 5);
this.spawnableMonsterList.add(new SpawnListEntry(EntityOcelot.class, 2, 1, 1));
this.spawnableCreatureList.add(new SpawnListEntry(EntityParrot.class, 40, 1, 2));
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(10);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("oak_bush", 8, (new GeneratorBush.Builder()).maxHeight(2).create());
treeGenerator.add("tall_eucalyptus", 1, (new GeneratorBulbTree.Builder()).minHeight(15).maxHeight(30).log(BOPWoods.EUCALYPTUS).leaves(BOPTrees.EUCALYPTUS).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(6);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
grassGenerator.add("tallgrass", 4, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("fern", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.FERN).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(0.5F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("dandelion", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 1, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.POPPY).create()));
// other plants
this.addGenerator("sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.SPROUT).create());
this.addGenerator("bushes", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.BUSH).create());
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.SHRUB).create());
this.addGenerator("rafflesia", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).with(BOPPlants.RAFFLESIA).create());
this.addGenerator("melons", GeneratorStage.FLOWERS, (new GeneratorFlora.Builder()).amountPerChunk(0.015625F).placeOn(this.topBlock).with(Blocks.MELON_BLOCK.getDefaultState()).create());
// water plants
this.addGenerator("lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(Blocks.WATERLILY.getDefaultState()).create());
this.addGenerator("medium_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.3F).with(BlockBOPLilypad.LilypadType.MEDIUM).create());
this.addGenerator("small_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BlockBOPLilypad.LilypadType.SMALL).create());
this.addGenerator("tiny_lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BlockBOPLilypad.LilypadType.TINY).create());
// gem
this.addGenerator("topaz", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TOPAZ).create());
}
}

View File

@ -1,138 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import java.util.Random;
import biomesoplenty.api.biome.BOPBiomes;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.BlockQueries;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.enums.BOPWoods;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPCoral;
import biomesoplenty.common.block.BlockBOPDirt;
import biomesoplenty.common.block.BlockBOPDoublePlant;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.block.BlockBOPLilypad;
import biomesoplenty.common.block.BlockBOPMushroom;
import biomesoplenty.common.block.BlockBOPPlant;
import biomesoplenty.common.util.biome.GeneratorUtils.ScatterYMethod;
import biomesoplenty.common.world.generator.GeneratorColumns;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWaterside;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBigTree;
import biomesoplenty.common.world.generator.tree.GeneratorTaigaTree;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenFossils;
public class BiomeGenFen extends BOPOverworldBiome
{
public BiomeGenFen()
{
super("fen", new PropsBuilder("Fen").withGuiColour(0xBAC481).withTemperature(0.4F).withRainfall(0.4F));
// terrain
this.terrainSettings.avgHeight(63).heightVariation(8, 6).octaves(1, 4, 3, 1, 1, 0);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.LOAMY);
this.fillerBlock = BOPBlocks.dirt.getDefaultState().withProperty(BlockBOPDirt.VARIANT, BlockBOPDirt.BOPDirtType.LOAMY);
this.canSpawnInBiome = false;
this.canGenerateRivers = false;
this.canGenerateVillages = false;
if (BOPBiomes.gravel_beach.isPresent())
{
this.beachBiomeLocation = ((BOPOverworldBiome)BOPBiomes.gravel_beach.get()).getResourceLocation();
}
this.addWeight(BOPClimates.COLD_SWAMP, 7);
// mud
this.addGenerator("mud", GeneratorStage.SAND_PASS2, (new GeneratorWaterside.Builder()).amountPerChunk(1).maxRadius(7).with(BOPBlocks.mud.getDefaultState()).create());
// trees and logs
GeneratorWeighted treeGenerator = new GeneratorWeighted(6);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("oak_tree", 1, (new GeneratorTwigletTree.Builder()).leaves(BOPTrees.DEAD).minHeight(5).maxHeight(10).leafChance(0.3F, 0.9F).create());
treeGenerator.add("dark_oak_tree", 7, (new GeneratorBigTree.Builder()).log(BlockPlanks.EnumType.DARK_OAK).leaves(BlockPlanks.EnumType.DARK_OAK).foliageHeight(2).maxHeight(12).create());
treeGenerator.add("birch_twiglet", 1, (new GeneratorTwigletTree.Builder()).log(BlockPlanks.EnumType.BIRCH).leaves(BlockPlanks.EnumType.BIRCH).minHeight(2).maxHeight(4).leafChance(0.3F, 0.9F).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(5.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 4, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("doublegrass", 3, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.GRASS).create());
// other plants
this.addGenerator("cattail", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(BOPPlants.CATTAIL).create());
this.addGenerator("double_cattail", GeneratorStage.FLOWERS,(new GeneratorDoubleFlora.Builder()).amountPerChunk(0.25F).with(BlockBOPDoublePlant.DoublePlantType.TALL_CATTAIL).create());
this.addGenerator("river_cane", GeneratorStage.FLOWERS,(new GeneratorColumns.Builder()).amountPerChunk(0.1F).generationAttempts(24).placeOn(BlockQueries.litFertileWaterside).with(BlockBOPPlant.paging.getVariantState(BOPPlants.RIVERCANE)).minHeight(1).maxHeight(3).create());
this.addGenerator("koru", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.KORU).create());
//this.addGenerator("shrubs", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).with(BOPPlants.SHRUB).create());
this.addGenerator("dead_leaf_piles", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(1.5F).placeOn(BlockQueries.fertile).with(BOPPlants.DEADLEAFPILE).generationAttempts(64).create());
// water plants
this.addGenerator("water_reeds", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(15.0F).with(BOPPlants.REED).generationAttempts(32).create());
this.addGenerator("lily", GeneratorStage.LILYPAD, (new GeneratorFlora.Builder()).amountPerChunk(0.25F).with(Blocks.WATERLILY.getDefaultState()).create());
// shrooms
this.addGenerator("flat_mushroom", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.1F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.FLAT_MUSHROOM).create());
this.addGenerator("toadstools", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).generationAttempts(16).with(BlockBOPMushroom.MushroomType.TOADSTOOL).create());
this.addGenerator("brown_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).generationAttempts(16).with(Blocks.BROWN_MUSHROOM.getDefaultState()).create());
this.addGenerator("red_mushrooms", GeneratorStage.SHROOM,(new GeneratorFlora.Builder()).amountPerChunk(0.4F).generationAttempts(16).with(Blocks.RED_MUSHROOM.getDefaultState()).create());
// gem
this.addGenerator("malachite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.MALACHITE).create());
}
@Override
public void decorate(World worldIn, Random rand, BlockPos pos)
{
super.decorate(worldIn, rand, pos);
if(net.minecraftforge.event.terraingen.TerrainGen.decorate(worldIn, rand, pos, net.minecraftforge.event.terraingen.DecorateBiomeEvent.Decorate.EventType.FOSSIL))
if (rand.nextInt(64) == 0)
{
(new WorldGenFossils()).generate(worldIn, rand, pos);
}
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0xC1BE7F);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0xABBF65);
}
}

View File

@ -1,76 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.enums.BOPClimates;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorProfileTree;
import biomesoplenty.common.world.generator.tree.GeneratorTwigletTree;
import net.minecraft.block.BlockFlower.EnumFlowerType;
import net.minecraft.block.material.Material;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockPlanks;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.util.math.BlockPos;
public class BiomeGenFlowerField extends BOPOverworldBiome
{
public BiomeGenFlowerField()
{
super("flower_field", new PropsBuilder("Flower Field").withGuiColour(4044093).withTemperature(0.7F).withRainfall(0.7F));
// terrain
this.terrainSettings.avgHeight(64).heightVariation(5, 5).octaves(0, 1, 2, 2, 1, 0);
this.addWeight(BOPClimates.WARM_TEMPERATE, 2);
this.canGenerateVillages = false;
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(3.0F);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("small_bush", 1, (new GeneratorFlora.Builder()).placeOn(this.topBlock).replace(Material.AIR).withNonDecayingLeaf(BlockPlanks.EnumType.OAK).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(17.5F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("pink_tulip", 6, (new GeneratorFlora.Builder().with(EnumFlowerType.PINK_TULIP).create()));
flowerGenerator.add("white_tulip", 9, (new GeneratorFlora.Builder().with(EnumFlowerType.WHITE_TULIP).create()));
flowerGenerator.add("orange_tulip", 11, (new GeneratorFlora.Builder().with(EnumFlowerType.ORANGE_TULIP).create()));
flowerGenerator.add("red_tulip", 14, (new GeneratorFlora.Builder().with(EnumFlowerType.RED_TULIP).create()));
flowerGenerator.add("oxeye_daisy", 3, (new GeneratorFlora.Builder().with(EnumFlowerType.OXEYE_DAISY).create()));
flowerGenerator.add("dandelion", 3, (new GeneratorFlora.Builder().with(EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 3, (new GeneratorFlora.Builder().with(EnumFlowerType.POPPY).create()));
flowerGenerator.add("white_anemone", 2, (new GeneratorFlora.Builder().with(BOPFlowers.WHITE_ANEMONE)).create());
flowerGenerator.add("houstonia", 2, (new GeneratorFlora.Builder().with(EnumFlowerType.HOUSTONIA).create()));
flowerGenerator.add("rose", 1, (new GeneratorDoubleFlora.Builder()).amountPerChunk(1).with(BlockDoublePlant.EnumPlantType.ROSE).create());
flowerGenerator.add("syringa", 1, (new GeneratorDoubleFlora.Builder()).amountPerChunk(1).with(BlockDoublePlant.EnumPlantType.SYRINGA).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(20.0F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("wheatgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.WHEATGRASS).create());
//grassGenerator.add("dampgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
grassGenerator.add("tallgrass", 2, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
// gem
this.addGenerator("peridot", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.PERIDOT).create());
}
}

View File

@ -1,104 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.block.IBlockPosQuery;
import biomesoplenty.api.enums.BOPFlowers;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.enums.BOPPlants;
import biomesoplenty.api.enums.BOPTrees;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.block.BlockBOPGrass;
import biomesoplenty.common.util.block.BlockQuery;
import biomesoplenty.common.world.generator.GeneratorBigFlower;
import biomesoplenty.common.world.generator.GeneratorDoubleFlora;
import biomesoplenty.common.world.generator.GeneratorFlora;
import biomesoplenty.common.world.generator.GeneratorGrass;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import biomesoplenty.common.world.generator.GeneratorSplatter;
import biomesoplenty.common.world.generator.GeneratorWeighted;
import biomesoplenty.common.world.generator.tree.GeneratorBush;
import net.minecraft.block.BlockDoublePlant;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockFlower.EnumFlowerType;
import net.minecraft.block.BlockTallGrass;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
public class BiomeGenFlowerIsland extends BOPOverworldBiome
{
public BiomeGenFlowerIsland()
{
super("flower_island", new PropsBuilder("Flower Island").withGuiColour(0x74D374).withTemperature(0.8F).withRainfall(0.8F));
// terrain
this.terrainSettings.avgHeight(70).heightVariation(10, 15).octaves(0, 0, 1, 1, 2, 2);
this.topBlock = BOPBlocks.grass.getDefaultState().withProperty(BlockBOPGrass.VARIANT, BlockBOPGrass.BOPGrassType.DAISY);
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
this.canGenerateRivers = false;
clearWeights();
this.spawnableMonsterList.clear();
this.spawnableCreatureList.clear();
// regular grass
IBlockPosQuery emptyGrass = BlockQuery.buildAnd().withAirAbove().states(this.topBlock).create();
this.addGenerator("grass_splatter", GeneratorStage.SAND, (new GeneratorSplatter.Builder()).amountPerChunk(6.0F).replace(emptyGrass).with(Blocks.GRASS.getDefaultState()).create());
// trees
GeneratorWeighted treeGenerator = new GeneratorWeighted(1);
this.addGenerator("trees", GeneratorStage.TREE, treeGenerator);
treeGenerator.add("red_big_flowers", 1, (new GeneratorBigFlower.Builder()).flowerType(GeneratorBigFlower.BigFlowerType.RED).create());
treeGenerator.add("yellow_big_flowers", 1, (new GeneratorBigFlower.Builder()).flowerType(GeneratorBigFlower.BigFlowerType.YELLOW).create());
treeGenerator.add("oak_bush", 2, (new GeneratorBush.Builder()).maxHeight(2).altLeaves(BOPTrees.FLOWERING).create());
// grasses
GeneratorWeighted grassGenerator = new GeneratorWeighted(0.75F);
this.addGenerator("grass", GeneratorStage.GRASS, grassGenerator);
grassGenerator.add("tallgrass", 4, (new GeneratorGrass.Builder()).with(BlockTallGrass.EnumType.GRASS).create());
grassGenerator.add("shortgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.SHORTGRASS).create());
grassGenerator.add("mediumgrass", 1, (new GeneratorGrass.Builder()).with(BOPPlants.MEDIUMGRASS).create());
//grassGenerator.add("dampgrass", 2, (new GeneratorGrass.Builder()).with(BOPPlants.DAMPGRASS).create());
// other plants
this.addGenerator("clover_patches", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.2F).generationAttempts(128).with(BOPPlants.CLOVERPATCH).create());
this.addGenerator("sprouts", GeneratorStage.FLOWERS,(new GeneratorFlora.Builder()).amountPerChunk(0.5F).with(BOPPlants.SPROUT).create());
// flowers
GeneratorWeighted flowerGenerator = new GeneratorWeighted(4.0F);
this.addGenerator("flowers", GeneratorStage.FLOWERS, flowerGenerator);
flowerGenerator.add("dandelion", 3, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.DANDELION).create()));
flowerGenerator.add("poppy", 5, (new GeneratorFlora.Builder().with(EnumFlowerType.POPPY).create()));
flowerGenerator.add("white_anemones", 4, (new GeneratorFlora.Builder().with(BOPFlowers.WHITE_ANEMONE).create()));
flowerGenerator.add("blue_hydrangeas", 2, (new GeneratorFlora.Builder().with(BOPFlowers.BLUE_HYDRANGEA).create()));
flowerGenerator.add("sunflowers", 1, (new GeneratorDoubleFlora.Builder()).with(BlockDoublePlant.EnumPlantType.SUNFLOWER).create());
flowerGenerator.add("oxeye_daisy", 2, (new GeneratorFlora.Builder().with(BlockFlower.EnumFlowerType.OXEYE_DAISY).create()));
flowerGenerator.add("rose", 2, (new GeneratorDoubleFlora.Builder().with(BlockDoublePlant.EnumPlantType.ROSE).create()));
// gem
this.addGenerator("topaz", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TOPAZ).create());
}
@Override
public int getGrassColorAtPos(BlockPos pos)
{
return getModdedBiomeGrassColor(0x74D374);
}
@Override
public int getFoliageColorAtPos(BlockPos pos)
{
return getModdedBiomeFoliageColor(0x66E266);
}
}

View File

@ -1,48 +0,0 @@
/*******************************************************************************
* Copyright 2015-2016, the Biomes O' Plenty Team
*
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
*
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
******************************************************************************/
package biomesoplenty.common.biome.overworld;
import biomesoplenty.api.block.BOPBlocks;
import biomesoplenty.api.enums.BOPGems;
import biomesoplenty.api.generation.GeneratorStage;
import biomesoplenty.common.world.generator.GeneratorOreSingle;
import net.minecraft.entity.monster.EntityPolarBear;
import net.minecraft.init.Blocks;
import net.minecraft.world.biome.Biome;
public class BiomeGenGlacier extends BOPOverworldBiome
{
public BiomeGenGlacier()
{
super("glacier", new PropsBuilder("Glacier").withTemperature(-0.5F).withRainfall(0.2F).withGuiColour(11582425));
// terrain
this.terrainSettings.avgHeight(88).heightVariation(8, 10).octaves(0, 1, 1, 3, 1, 0);
this.topBlock = Blocks.ICE.getDefaultState();
this.fillerBlock = BOPBlocks.hard_ice.getDefaultState();
this.avgDirtDepth = 16;
this.canSpawnInBiome = false;
this.canGenerateVillages = false;
this.canGenerateRivers = false;
this.hasBiomeEssence = false;
this.spawnableCreatureList.clear();
this.spawnableCreatureList.add(new SpawnListEntry(EntityPolarBear.class, 1, 1, 2));
clearWeights();
// gem
this.addGenerator("tanzanite", GeneratorStage.SAND, (new GeneratorOreSingle.Builder()).amountPerChunk(12).with(BOPGems.TANZANITE).create());
}
}

Some files were not shown because too many files have changed in this diff Show More