feat: geodes (#1697)

Signed-off-by: Alexander Medvedev <lilalexmed@proton.me>
Co-authored-by: Alexander Medvedev <lilalexmed@proton.me>

Author: RoosterBooster007

pumpkin-codegen/src/configured_feature.rs

@@ -89,6 +89,7 @@ pub fn build() -> TokenStream {
                 simple_block::SimpleBlockFeature,
                 simple_random_selector::SimpleRandomFeature,
                 spring_feature::{BlockWrapper, SpringFeatureFeature},
+                geode::GeodeFeature,
                 tree::TreeFeature,
                 tree::trunk::{TrunkPlacer, TrunkType,
                     bending::BendingTrunkPlacer,
@@ -365,10 +366,80 @@ pub fn value_to_configured_feature(v: &Value) -> TokenStream {
                 })
             }
         }
+        "minecraft:geode" => {
+            let blocks = &config["blocks"];
+            let filling_provider = value_to_block_state_provider(&blocks["filling_provider"]);
+            let inner_layer_provider = value_to_block_state_provider(&blocks["inner_layer_provider"]);
+            let alternate_inner_layer_provider =
+                value_to_block_state_provider(&blocks["alternate_inner_layer_provider"]);
+            let middle_layer_provider = value_to_block_state_provider(&blocks["middle_layer_provider"]);
+            let outer_layer_provider = value_to_block_state_provider(&blocks["outer_layer_provider"]);
+            let inner_placements: Vec<TokenStream> = blocks["inner_placements"]
+                .as_array()
+                .map(|arr| arr.iter().map(|s| value_to_block_state_codec(s)).collect())
+                .unwrap_or_default();
+            let cannot_replace = value_to_block_wrapper(&blocks["cannot_replace"]);
+            let invalid_blocks = value_to_block_wrapper(&blocks["invalid_blocks"]);
+
+            let layers = &config["layers"];
+            let filling = layers["filling"].as_f64().unwrap_or(1.7);
+            let inner_layer = layers["inner_layer"].as_f64().unwrap_or(2.2);
+            let middle_layer = layers["middle_layer"].as_f64().unwrap_or(3.2);
+            let outer_layer = layers["outer_layer"].as_f64().unwrap_or(4.2);
+
+            let crack = &config["crack"];
+            let generate_crack_chance = crack["generate_crack_chance"].as_f64().unwrap_or(1.0);
+            let base_crack_size = crack["base_crack_size"].as_f64().unwrap_or(2.0);
+            let crack_point_offset = crack["crack_point_offset"].as_i64().unwrap_or(2) as i32;
+
+            let use_potential_placements_chance =
+                config["use_potential_placements_chance"].as_f64().unwrap_or(0.35);
+            let use_alternate_layer0_chance =
+                config["use_alternate_layer0_chance"].as_f64().unwrap_or(0.0);
+            let placements_require_layer0_alternate =
+                config["placements_require_layer0_alternate"].as_bool().unwrap_or(true);
+            let outer_wall_distance = value_to_int_provider(&config["outer_wall_distance"]);
+            let distribution_points = value_to_int_provider(&config["distribution_points"]);
+            let point_offset = value_to_int_provider(&config["point_offset"]);
+            let min_gen_offset = config["min_gen_offset"].as_i64().unwrap_or(-16) as i32;
+            let max_gen_offset = config["max_gen_offset"].as_i64().unwrap_or(16) as i32;
+            let noise_multiplier = config["noise_multiplier"].as_f64().unwrap_or(0.05);
+            let invalid_blocks_threshold =
+                config["invalid_blocks_threshold"].as_i64().unwrap_or(0) as i32;
+
+            quote! {
+                ConfiguredFeature::Geode(Box::new(GeodeFeature {
+                    filling_provider: #filling_provider,
+                    inner_layer_provider: #inner_layer_provider,
+                    alternate_inner_layer_provider: #alternate_inner_layer_provider,
+                    middle_layer_provider: #middle_layer_provider,
+                    outer_layer_provider: #outer_layer_provider,
+                    inner_placements: vec![#(#inner_placements),*],
+                    cannot_replace: #cannot_replace,
+                    invalid_blocks: #invalid_blocks,
+                    filling: #filling,
+                    inner_layer: #inner_layer,
+                    middle_layer: #middle_layer,
+                    outer_layer: #outer_layer,
+                    generate_crack_chance: #generate_crack_chance,
+                    base_crack_size: #base_crack_size,
+                    crack_point_offset: #crack_point_offset,
+                    use_potential_placements_chance: #use_potential_placements_chance,
+                    use_alternate_layer0_chance: #use_alternate_layer0_chance,
+                    placements_require_layer0_alternate: #placements_require_layer0_alternate,
+                    outer_wall_distance: #outer_wall_distance,
+                    distribution_points: #distribution_points,
+                    point_offset: #point_offset,
+                    min_gen_offset: #min_gen_offset,
+                    max_gen_offset: #max_gen_offset,
+                    noise_multiplier: #noise_multiplier,
+                    invalid_blocks_threshold: #invalid_blocks_threshold,
+                }))
+            }
+        },
         "minecraft:monster_room" => quote! { ConfiguredFeature::MonsterRoom(crate::generation::feature::features::monster_room::DungeonFeature {}) },
 
         // All TODO/empty features
-        "minecraft:geode" => quote! { ConfiguredFeature::Geode(crate::generation::feature::features::geode::GeodeFeature {}) },
         "minecraft:fossil" => quote! { ConfiguredFeature::Fossil(crate::generation::feature::features::fossil::FossilFeature {}) },
         "minecraft:lake" => quote! { ConfiguredFeature::Lake(crate::generation::feature::features::lake::LakeFeature {}) },
         "minecraft:disk" => quote! { ConfiguredFeature::Disk(crate::generation::feature::features::disk::DiskFeature {}) },

pumpkin-data/src/generated/configured_features_generated.rs

@@ -20,6 +20,7 @@ fn build_configured_features() -> std::collections::HashMap<String, ConfiguredFe
         block_column::{BlockColumnFeature, Layer},
         end_spike::{EndSpikeFeature, Spike},
         fallen_tree::FallenTreeFeature,
+        geode::GeodeFeature,
         nether_forest_vegetation::NetherForestVegetationFeature,
         netherrack_replace_blobs::ReplaceBlobsFeature,
         ore::{OreFeature, OreTarget},
@@ -144,7 +145,108 @@ fn build_configured_features() -> std::collections::HashMap<String, ConfiguredFe
     );
     map.insert(
         "amethyst_geode".to_string(),
-        ConfiguredFeature::Geode(crate::generation::feature::features::geode::GeodeFeature {}),
+        ConfiguredFeature::Geode(Box::new(GeodeFeature {
+            filling_provider: BlockStateProvider::Simple(SimpleStateProvider {
+                state: BlockStateCodec {
+                    name: &pumpkin_data::Block::AIR,
+                    properties: None,
+                },
+            }),
+            inner_layer_provider: BlockStateProvider::Simple(SimpleStateProvider {
+                state: BlockStateCodec {
+                    name: &pumpkin_data::Block::AMETHYST_BLOCK,
+                    properties: None,
+                },
+            }),
+            alternate_inner_layer_provider: BlockStateProvider::Simple(SimpleStateProvider {
+                state: BlockStateCodec {
+                    name: &pumpkin_data::Block::BUDDING_AMETHYST,
+                    properties: None,
+                },
+            }),
+            middle_layer_provider: BlockStateProvider::Simple(SimpleStateProvider {
+                state: BlockStateCodec {
+                    name: &pumpkin_data::Block::CALCITE,
+                    properties: None,
+                },
+            }),
+            outer_layer_provider: BlockStateProvider::Simple(SimpleStateProvider {
+                state: BlockStateCodec {
+                    name: &pumpkin_data::Block::SMOOTH_BASALT,
+                    properties: None,
+                },
+            }),
+            inner_placements: vec![
+                {
+                    let mut props = std::collections::HashMap::new();
+                    props.insert("facing".to_string(), "up".to_string());
+                    props.insert("waterlogged".to_string(), "false".to_string());
+                    BlockStateCodec {
+                        name: &pumpkin_data::Block::SMALL_AMETHYST_BUD,
+                        properties: Some(props),
+                    }
+                },
+                {
+                    let mut props = std::collections::HashMap::new();
+                    props.insert("facing".to_string(), "up".to_string());
+                    props.insert("waterlogged".to_string(), "false".to_string());
+                    BlockStateCodec {
+                        name: &pumpkin_data::Block::MEDIUM_AMETHYST_BUD,
+                        properties: Some(props),
+                    }
+                },
+                {
+                    let mut props = std::collections::HashMap::new();
+                    props.insert("facing".to_string(), "up".to_string());
+                    props.insert("waterlogged".to_string(), "false".to_string());
+                    BlockStateCodec {
+                        name: &pumpkin_data::Block::LARGE_AMETHYST_BUD,
+                        properties: Some(props),
+                    }
+                },
+                {
+                    let mut props = std::collections::HashMap::new();
+                    props.insert("facing".to_string(), "up".to_string());
+                    props.insert("waterlogged".to_string(), "false".to_string());
+                    BlockStateCodec {
+                        name: &pumpkin_data::Block::AMETHYST_CLUSTER,
+                        properties: Some(props),
+                    }
+                },
+            ],
+            cannot_replace: BlockWrapper::Single("#minecraft:features_cannot_replace".to_string()),
+            invalid_blocks: BlockWrapper::Single("#minecraft:geode_invalid_blocks".to_string()),
+            filling: 1.7f64,
+            inner_layer: 2.2f64,
+            middle_layer: 3.2f64,
+            outer_layer: 4.2f64,
+            generate_crack_chance: 0.95f64,
+            base_crack_size: 2f64,
+            crack_point_offset: 2i32,
+            use_potential_placements_chance: 0.35f64,
+            use_alternate_layer0_chance: 0.083f64,
+            placements_require_layer0_alternate: true,
+            outer_wall_distance: IntProvider::Object(NormalIntProvider::Uniform(
+                UniformIntProvider {
+                    min_inclusive: 4i32,
+                    max_inclusive: 6i32,
+                },
+            )),
+            distribution_points: IntProvider::Object(NormalIntProvider::Uniform(
+                UniformIntProvider {
+                    min_inclusive: 3i32,
+                    max_inclusive: 4i32,
+                },
+            )),
+            point_offset: IntProvider::Object(NormalIntProvider::Uniform(UniformIntProvider {
+                min_inclusive: 1i32,
+                max_inclusive: 2i32,
+            })),
+            min_gen_offset: -16i32,
+            max_gen_offset: 16i32,
+            noise_multiplier: 0.05f64,
+            invalid_blocks_threshold: 1i32,
+        })),
     );
     map.insert(
         "azalea_tree".to_string(),

pumpkin-data/src/generated/tag.rs

@@ -3,11 +3,11 @@ use pumpkin_util::version::MinecraftVersion;
 pub type Tag = (&'static [&'static str], &'static [u16]);
 #[derive(Eq, PartialEq, Hash, Debug, Clone, Copy)]
 pub enum RegistryKey {
-    BannerPattern,
-    Block,
     CatVariant,
     DamageType,
     Dialog,
+    BannerPattern,
+    Block,
     DimensionType,
     Enchantment,
     EntityType,
@@ -27,8 +27,8 @@ impl RegistryKey {
             "block" => Some(Self::Block),
             "cat_variant" => Some(Self::CatVariant),
             "damage_type" => Some(Self::DamageType),
-            "dialog" => Some(Self::Dialog),
             "dimension_type" => Some(Self::DimensionType),
+            "dialog" => Some(Self::Dialog),
             "enchantment" => Some(Self::Enchantment),
             "entity_type" => Some(Self::EntityType),
             "fluid" => Some(Self::Fluid),
@@ -48,8 +48,8 @@ impl RegistryKey {
             Self::Block => "block",
             Self::CatVariant => "cat_variant",
             Self::DamageType => "damage_type",
-            Self::Dialog => "dialog",
             Self::DimensionType => "dimension_type",
+            Self::Dialog => "dialog",
             Self::Enchantment => "enchantment",
             Self::EntityType => "entity_type",
             Self::Fluid => "fluid",

pumpkin-world/src/generation/feature/configured_features.rs

@@ -131,7 +131,7 @@ pub enum ConfiguredFeature {
     RandomSelector(RandomFeature),
     SimpleRandomSelector(SimpleRandomFeature),
     RandomBooleanSelector(RandomBooleanFeature),
-    Geode(GeodeFeature),
+    Geode(Box<GeodeFeature>),
     DripstoneCluster(DripstoneClusterFeature),
     LargeDripstone(LargeDripstoneFeature),
     PointedDripstone(SmallDripstoneFeature),
@@ -294,6 +294,15 @@ impl ConfiguredFeature {
             Self::SeaPickle(feature) => {
                 feature.generate(chunk, min_y, height, feature_name, random, pos)
             }
+            Self::Geode(feature) => feature.generate(
+                chunk,
+                block_registry,
+                min_y,
+                height,
+                feature_name,
+                random,
+                pos,
+            ),
             Self::Kelp(feature) => {
                 feature.generate(chunk, min_y, height, feature_name, random, pos)
             }