Skip to main content

steel_registry/generated/
vanilla_placed_features.rs

1use crate::{feature::*, vanilla_blocks, vanilla_fluids};
2use std::sync::{LazyLock, OnceLock};
3use steel_utils::value_providers::{
4    FloatProvider, HeightProvider, IntProvider, UniformIntProvider, VerticalAnchor,
5    WeightedIntProvider,
6};
7use steel_utils::{Direction, Identifier};
8pub static ACACIA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
9    key: Identifier::vanilla_static("acacia"),
10    data: PlacedFeatureData {
11        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ACACIA),
12        placement: vec![PlacementModifier::BlockPredicateFilter {
13            predicate: BlockPredicate::WouldSurvive {
14                state: BlockStateData {
15                    block: &vanilla_blocks::ACACIA_SAPLING,
16                    properties: &[("stage", "0")],
17                },
18                offset: [0i32, 0i32, 0i32],
19            },
20        }],
21    },
22    id: OnceLock::new(),
23});
24pub static ACACIA_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
25    key: Identifier::vanilla_static("acacia_checked"),
26    data: PlacedFeatureData {
27        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ACACIA),
28        placement: vec![PlacementModifier::BlockPredicateFilter {
29            predicate: BlockPredicate::WouldSurvive {
30                state: BlockStateData {
31                    block: &vanilla_blocks::ACACIA_SAPLING,
32                    properties: &[("stage", "0")],
33                },
34                offset: [0i32, 0i32, 0i32],
35            },
36        }],
37    },
38    id: OnceLock::new(),
39});
40pub static AMETHYST_GEODE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
41    key: Identifier::vanilla_static("amethyst_geode"),
42    data: PlacedFeatureData {
43        feature: ConfiguredFeatureRef::Reference(
44            &crate::vanilla_configured_features::AMETHYST_GEODE,
45        ),
46        placement: vec![
47            PlacementModifier::RarityFilter { chance: 24i32 },
48            PlacementModifier::InSquare,
49            PlacementModifier::HeightRange {
50                height: HeightProvider::Uniform {
51                    min_inclusive: VerticalAnchor::AboveBottom(6i32),
52                    max_inclusive: VerticalAnchor::Absolute(30i32),
53                },
54            },
55            PlacementModifier::Biome,
56        ],
57    },
58    id: OnceLock::new(),
59});
60pub static BAMBOO: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
61    key: Identifier::vanilla_static("bamboo"),
62    data: PlacedFeatureData {
63        feature: ConfiguredFeatureRef::Reference(
64            &crate::vanilla_configured_features::BAMBOO_SOME_PODZOL,
65        ),
66        placement: vec![
67            PlacementModifier::NoiseBasedCount {
68                noise_to_count_ratio: 160i32,
69                noise_factor: 80f64,
70                noise_offset: 0.3f64,
71            },
72            PlacementModifier::InSquare,
73            PlacementModifier::Heightmap {
74                heightmap: FeatureHeightmap::WorldSurfaceWg,
75            },
76            PlacementModifier::Biome,
77        ],
78    },
79    id: OnceLock::new(),
80});
81pub static BAMBOO_LIGHT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
82    key: Identifier::vanilla_static("bamboo_light"),
83    data: PlacedFeatureData {
84        feature: ConfiguredFeatureRef::Reference(
85            &crate::vanilla_configured_features::BAMBOO_NO_PODZOL,
86        ),
87        placement: vec![
88            PlacementModifier::RarityFilter { chance: 4i32 },
89            PlacementModifier::InSquare,
90            PlacementModifier::Heightmap {
91                heightmap: FeatureHeightmap::MotionBlocking,
92            },
93            PlacementModifier::Biome,
94        ],
95    },
96    id: OnceLock::new(),
97});
98pub static BAMBOO_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
99    key: Identifier::vanilla_static("bamboo_vegetation"),
100    data: PlacedFeatureData {
101        feature: ConfiguredFeatureRef::Reference(
102            &crate::vanilla_configured_features::BAMBOO_VEGETATION,
103        ),
104        placement: vec![
105            PlacementModifier::Count {
106                count: IntProvider::WeightedList {
107                    distribution: vec![
108                        WeightedIntProvider {
109                            data: IntProvider::Constant(30i32),
110                            weight: 9i32,
111                        },
112                        WeightedIntProvider {
113                            data: IntProvider::Constant(31i32),
114                            weight: 1i32,
115                        },
116                    ],
117                },
118            },
119            PlacementModifier::InSquare,
120            PlacementModifier::SurfaceWaterDepthFilter {
121                max_water_depth: 0i32,
122            },
123            PlacementModifier::Heightmap {
124                heightmap: FeatureHeightmap::OceanFloor,
125            },
126            PlacementModifier::Biome,
127        ],
128    },
129    id: OnceLock::new(),
130});
131pub static BASALT_BLOBS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
132    key: Identifier::vanilla_static("basalt_blobs"),
133    data: PlacedFeatureData {
134        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BASALT_BLOBS),
135        placement: vec![
136            PlacementModifier::Count {
137                count: IntProvider::Constant(75i32),
138            },
139            PlacementModifier::InSquare,
140            PlacementModifier::HeightRange {
141                height: HeightProvider::Uniform {
142                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
143                    max_inclusive: VerticalAnchor::BelowTop(0i32),
144                },
145            },
146            PlacementModifier::Biome,
147        ],
148    },
149    id: OnceLock::new(),
150});
151pub static BASALT_PILLAR: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
152    key: Identifier::vanilla_static("basalt_pillar"),
153    data: PlacedFeatureData {
154        feature: ConfiguredFeatureRef::Reference(
155            &crate::vanilla_configured_features::BASALT_PILLAR,
156        ),
157        placement: vec![
158            PlacementModifier::Count {
159                count: IntProvider::Constant(10i32),
160            },
161            PlacementModifier::InSquare,
162            PlacementModifier::HeightRange {
163                height: HeightProvider::Uniform {
164                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
165                    max_inclusive: VerticalAnchor::BelowTop(0i32),
166                },
167            },
168            PlacementModifier::Biome,
169        ],
170    },
171    id: OnceLock::new(),
172});
173pub static BIRCH_BEES_0002: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
174    key: Identifier::vanilla_static("birch_bees_0002"),
175    data: PlacedFeatureData {
176        feature: ConfiguredFeatureRef::Reference(
177            &crate::vanilla_configured_features::BIRCH_BEES_0002,
178        ),
179        placement: vec![PlacementModifier::BlockPredicateFilter {
180            predicate: BlockPredicate::WouldSurvive {
181                state: BlockStateData {
182                    block: &vanilla_blocks::BIRCH_SAPLING,
183                    properties: &[("stage", "0")],
184                },
185                offset: [0i32, 0i32, 0i32],
186            },
187        }],
188    },
189    id: OnceLock::new(),
190});
191pub static BIRCH_BEES_0002_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
192    key: Identifier::vanilla_static("birch_bees_0002_leaf_litter"),
193    data: PlacedFeatureData {
194        feature: ConfiguredFeatureRef::Reference(
195            &crate::vanilla_configured_features::BIRCH_BEES_0002_LEAF_LITTER,
196        ),
197        placement: vec![PlacementModifier::BlockPredicateFilter {
198            predicate: BlockPredicate::WouldSurvive {
199                state: BlockStateData {
200                    block: &vanilla_blocks::BIRCH_SAPLING,
201                    properties: &[("stage", "0")],
202                },
203                offset: [0i32, 0i32, 0i32],
204            },
205        }],
206    },
207    id: OnceLock::new(),
208});
209pub static BIRCH_BEES_002: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
210    key: Identifier::vanilla_static("birch_bees_002"),
211    data: PlacedFeatureData {
212        feature: ConfiguredFeatureRef::Reference(
213            &crate::vanilla_configured_features::BIRCH_BEES_002,
214        ),
215        placement: vec![PlacementModifier::BlockPredicateFilter {
216            predicate: BlockPredicate::WouldSurvive {
217                state: BlockStateData {
218                    block: &vanilla_blocks::BIRCH_SAPLING,
219                    properties: &[("stage", "0")],
220                },
221                offset: [0i32, 0i32, 0i32],
222            },
223        }],
224    },
225    id: OnceLock::new(),
226});
227pub static BIRCH_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
228    key: Identifier::vanilla_static("birch_checked"),
229    data: PlacedFeatureData {
230        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BIRCH),
231        placement: vec![PlacementModifier::BlockPredicateFilter {
232            predicate: BlockPredicate::WouldSurvive {
233                state: BlockStateData {
234                    block: &vanilla_blocks::BIRCH_SAPLING,
235                    properties: &[("stage", "0")],
236                },
237                offset: [0i32, 0i32, 0i32],
238            },
239        }],
240    },
241    id: OnceLock::new(),
242});
243pub static BIRCH_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
244    key: Identifier::vanilla_static("birch_leaf_litter"),
245    data: PlacedFeatureData {
246        feature: ConfiguredFeatureRef::Reference(
247            &crate::vanilla_configured_features::BIRCH_LEAF_LITTER,
248        ),
249        placement: vec![PlacementModifier::BlockPredicateFilter {
250            predicate: BlockPredicate::WouldSurvive {
251                state: BlockStateData {
252                    block: &vanilla_blocks::BIRCH_SAPLING,
253                    properties: &[("stage", "0")],
254                },
255                offset: [0i32, 0i32, 0i32],
256            },
257        }],
258    },
259    id: OnceLock::new(),
260});
261pub static BIRCH_TALL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
262    key: Identifier::vanilla_static("birch_tall"),
263    data: PlacedFeatureData {
264        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BIRCH_TALL),
265        placement: vec![
266            PlacementModifier::Count {
267                count: IntProvider::WeightedList {
268                    distribution: vec![
269                        WeightedIntProvider {
270                            data: IntProvider::Constant(10i32),
271                            weight: 9i32,
272                        },
273                        WeightedIntProvider {
274                            data: IntProvider::Constant(11i32),
275                            weight: 1i32,
276                        },
277                    ],
278                },
279            },
280            PlacementModifier::InSquare,
281            PlacementModifier::SurfaceWaterDepthFilter {
282                max_water_depth: 0i32,
283            },
284            PlacementModifier::Heightmap {
285                heightmap: FeatureHeightmap::OceanFloor,
286            },
287            PlacementModifier::Biome,
288        ],
289    },
290    id: OnceLock::new(),
291});
292pub static BLACKSTONE_BLOBS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
293    key: Identifier::vanilla_static("blackstone_blobs"),
294    data: PlacedFeatureData {
295        feature: ConfiguredFeatureRef::Reference(
296            &crate::vanilla_configured_features::BLACKSTONE_BLOBS,
297        ),
298        placement: vec![
299            PlacementModifier::Count {
300                count: IntProvider::Constant(25i32),
301            },
302            PlacementModifier::InSquare,
303            PlacementModifier::HeightRange {
304                height: HeightProvider::Uniform {
305                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
306                    max_inclusive: VerticalAnchor::BelowTop(0i32),
307                },
308            },
309            PlacementModifier::Biome,
310        ],
311    },
312    id: OnceLock::new(),
313});
314pub static BLUE_ICE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
315    key: Identifier::vanilla_static("blue_ice"),
316    data: PlacedFeatureData {
317        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BLUE_ICE),
318        placement: vec![
319            PlacementModifier::Count {
320                count: IntProvider::Uniform {
321                    min_inclusive: 0i32,
322                    max_inclusive: 19i32,
323                },
324            },
325            PlacementModifier::InSquare,
326            PlacementModifier::HeightRange {
327                height: HeightProvider::Uniform {
328                    min_inclusive: VerticalAnchor::Absolute(30i32),
329                    max_inclusive: VerticalAnchor::Absolute(61i32),
330                },
331            },
332            PlacementModifier::Biome,
333        ],
334    },
335    id: OnceLock::new(),
336});
337pub static BROWN_MUSHROOM_NETHER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
338    key: Identifier::vanilla_static("brown_mushroom_nether"),
339    data: PlacedFeatureData {
340        feature: ConfiguredFeatureRef::Reference(
341            &crate::vanilla_configured_features::BROWN_MUSHROOM,
342        ),
343        placement: vec![
344            PlacementModifier::RarityFilter { chance: 2i32 },
345            PlacementModifier::InSquare,
346            PlacementModifier::HeightRange {
347                height: HeightProvider::Uniform {
348                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
349                    max_inclusive: VerticalAnchor::BelowTop(0i32),
350                },
351            },
352            PlacementModifier::Biome,
353            PlacementModifier::Count {
354                count: IntProvider::Constant(96i32),
355            },
356            PlacementModifier::RandomOffset {
357                xz_spread: IntProvider::Trapezoid {
358                    min: -7i32,
359                    max: 7i32,
360                    plateau: 0i32,
361                },
362                y_spread: IntProvider::Trapezoid {
363                    min: -3i32,
364                    max: 3i32,
365                    plateau: 0i32,
366                },
367            },
368            PlacementModifier::BlockPredicateFilter {
369                predicate: BlockPredicate::MatchingBlockTag {
370                    tag: Identifier::vanilla_static("air"),
371                    offset: [0i32, 0i32, 0i32],
372                },
373            },
374        ],
375    },
376    id: OnceLock::new(),
377});
378pub static BROWN_MUSHROOM_NORMAL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
379    key: Identifier::vanilla_static("brown_mushroom_normal"),
380    data: PlacedFeatureData {
381        feature: ConfiguredFeatureRef::Reference(
382            &crate::vanilla_configured_features::BROWN_MUSHROOM,
383        ),
384        placement: vec![
385            PlacementModifier::RarityFilter { chance: 256i32 },
386            PlacementModifier::InSquare,
387            PlacementModifier::Heightmap {
388                heightmap: FeatureHeightmap::MotionBlocking,
389            },
390            PlacementModifier::Biome,
391            PlacementModifier::Count {
392                count: IntProvider::Constant(96i32),
393            },
394            PlacementModifier::RandomOffset {
395                xz_spread: IntProvider::Trapezoid {
396                    min: -7i32,
397                    max: 7i32,
398                    plateau: 0i32,
399                },
400                y_spread: IntProvider::Trapezoid {
401                    min: -3i32,
402                    max: 3i32,
403                    plateau: 0i32,
404                },
405            },
406            PlacementModifier::BlockPredicateFilter {
407                predicate: BlockPredicate::MatchingBlockTag {
408                    tag: Identifier::vanilla_static("air"),
409                    offset: [0i32, 0i32, 0i32],
410                },
411            },
412        ],
413    },
414    id: OnceLock::new(),
415});
416pub static BROWN_MUSHROOM_OLD_GROWTH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
417    key: Identifier::vanilla_static("brown_mushroom_old_growth"),
418    data: PlacedFeatureData {
419        feature: ConfiguredFeatureRef::Reference(
420            &crate::vanilla_configured_features::BROWN_MUSHROOM,
421        ),
422        placement: vec![
423            PlacementModifier::Count {
424                count: IntProvider::Constant(3i32),
425            },
426            PlacementModifier::RarityFilter { chance: 4i32 },
427            PlacementModifier::InSquare,
428            PlacementModifier::Heightmap {
429                heightmap: FeatureHeightmap::MotionBlocking,
430            },
431            PlacementModifier::Biome,
432            PlacementModifier::Count {
433                count: IntProvider::Constant(96i32),
434            },
435            PlacementModifier::RandomOffset {
436                xz_spread: IntProvider::Trapezoid {
437                    min: -7i32,
438                    max: 7i32,
439                    plateau: 0i32,
440                },
441                y_spread: IntProvider::Trapezoid {
442                    min: -3i32,
443                    max: 3i32,
444                    plateau: 0i32,
445                },
446            },
447            PlacementModifier::BlockPredicateFilter {
448                predicate: BlockPredicate::MatchingBlockTag {
449                    tag: Identifier::vanilla_static("air"),
450                    offset: [0i32, 0i32, 0i32],
451                },
452            },
453        ],
454    },
455    id: OnceLock::new(),
456});
457pub static BROWN_MUSHROOM_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
458    key: Identifier::vanilla_static("brown_mushroom_swamp"),
459    data: PlacedFeatureData {
460        feature: ConfiguredFeatureRef::Reference(
461            &crate::vanilla_configured_features::BROWN_MUSHROOM,
462        ),
463        placement: vec![
464            PlacementModifier::Count {
465                count: IntProvider::Constant(2i32),
466            },
467            PlacementModifier::InSquare,
468            PlacementModifier::Heightmap {
469                heightmap: FeatureHeightmap::MotionBlocking,
470            },
471            PlacementModifier::Biome,
472            PlacementModifier::Count {
473                count: IntProvider::Constant(96i32),
474            },
475            PlacementModifier::RandomOffset {
476                xz_spread: IntProvider::Trapezoid {
477                    min: -7i32,
478                    max: 7i32,
479                    plateau: 0i32,
480                },
481                y_spread: IntProvider::Trapezoid {
482                    min: -3i32,
483                    max: 3i32,
484                    plateau: 0i32,
485                },
486            },
487            PlacementModifier::BlockPredicateFilter {
488                predicate: BlockPredicate::MatchingBlockTag {
489                    tag: Identifier::vanilla_static("air"),
490                    offset: [0i32, 0i32, 0i32],
491                },
492            },
493        ],
494    },
495    id: OnceLock::new(),
496});
497pub static BROWN_MUSHROOM_TAIGA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
498    key: Identifier::vanilla_static("brown_mushroom_taiga"),
499    data: PlacedFeatureData {
500        feature: ConfiguredFeatureRef::Reference(
501            &crate::vanilla_configured_features::BROWN_MUSHROOM,
502        ),
503        placement: vec![
504            PlacementModifier::RarityFilter { chance: 4i32 },
505            PlacementModifier::InSquare,
506            PlacementModifier::Heightmap {
507                heightmap: FeatureHeightmap::MotionBlocking,
508            },
509            PlacementModifier::Biome,
510            PlacementModifier::Count {
511                count: IntProvider::Constant(96i32),
512            },
513            PlacementModifier::RandomOffset {
514                xz_spread: IntProvider::Trapezoid {
515                    min: -7i32,
516                    max: 7i32,
517                    plateau: 0i32,
518                },
519                y_spread: IntProvider::Trapezoid {
520                    min: -3i32,
521                    max: 3i32,
522                    plateau: 0i32,
523                },
524            },
525            PlacementModifier::BlockPredicateFilter {
526                predicate: BlockPredicate::MatchingBlockTag {
527                    tag: Identifier::vanilla_static("air"),
528                    offset: [0i32, 0i32, 0i32],
529                },
530            },
531        ],
532    },
533    id: OnceLock::new(),
534});
535pub static CAVE_VINES: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
536    key: Identifier::vanilla_static("cave_vines"),
537    data: PlacedFeatureData {
538        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::CAVE_VINE),
539        placement: vec![
540            PlacementModifier::Count {
541                count: IntProvider::Constant(188i32),
542            },
543            PlacementModifier::InSquare,
544            PlacementModifier::HeightRange {
545                height: HeightProvider::Uniform {
546                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
547                    max_inclusive: VerticalAnchor::Absolute(256i32),
548                },
549            },
550            PlacementModifier::EnvironmentScan {
551                direction_of_search: Direction::Up,
552                target_condition: BlockPredicate::HasSturdyFace {
553                    direction: Direction::Down,
554                    offset: [0i32, 0i32, 0i32],
555                },
556                allowed_search_condition: Some(BlockPredicate::MatchingBlockTag {
557                    tag: Identifier::vanilla_static("air"),
558                    offset: [0i32, 0i32, 0i32],
559                }),
560                max_steps: 12i32,
561            },
562            PlacementModifier::RandomOffset {
563                xz_spread: IntProvider::Constant(0i32),
564                y_spread: IntProvider::Constant(-1i32),
565            },
566            PlacementModifier::Biome,
567        ],
568    },
569    id: OnceLock::new(),
570});
571pub static CHERRY_BEES_005: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
572    key: Identifier::vanilla_static("cherry_bees_005"),
573    data: PlacedFeatureData {
574        feature: ConfiguredFeatureRef::Reference(
575            &crate::vanilla_configured_features::CHERRY_BEES_005,
576        ),
577        placement: vec![PlacementModifier::BlockPredicateFilter {
578            predicate: BlockPredicate::WouldSurvive {
579                state: BlockStateData {
580                    block: &vanilla_blocks::CHERRY_SAPLING,
581                    properties: &[("stage", "0")],
582                },
583                offset: [0i32, 0i32, 0i32],
584            },
585        }],
586    },
587    id: OnceLock::new(),
588});
589pub static CHERRY_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
590    key: Identifier::vanilla_static("cherry_checked"),
591    data: PlacedFeatureData {
592        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::CHERRY),
593        placement: vec![PlacementModifier::BlockPredicateFilter {
594            predicate: BlockPredicate::WouldSurvive {
595                state: BlockStateData {
596                    block: &vanilla_blocks::CHERRY_SAPLING,
597                    properties: &[("stage", "0")],
598                },
599                offset: [0i32, 0i32, 0i32],
600            },
601        }],
602    },
603    id: OnceLock::new(),
604});
605pub static CHORUS_PLANT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
606    key: Identifier::vanilla_static("chorus_plant"),
607    data: PlacedFeatureData {
608        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::CHORUS_PLANT),
609        placement: vec![
610            PlacementModifier::Count {
611                count: IntProvider::Uniform {
612                    min_inclusive: 0i32,
613                    max_inclusive: 4i32,
614                },
615            },
616            PlacementModifier::InSquare,
617            PlacementModifier::Heightmap {
618                heightmap: FeatureHeightmap::MotionBlocking,
619            },
620            PlacementModifier::Biome,
621        ],
622    },
623    id: OnceLock::new(),
624});
625pub static CLASSIC_VINES_CAVE_FEATURE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
626    key: Identifier::vanilla_static("classic_vines_cave_feature"),
627    data: PlacedFeatureData {
628        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::VINES),
629        placement: vec![
630            PlacementModifier::Count {
631                count: IntProvider::Constant(256i32),
632            },
633            PlacementModifier::InSquare,
634            PlacementModifier::HeightRange {
635                height: HeightProvider::Uniform {
636                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
637                    max_inclusive: VerticalAnchor::Absolute(256i32),
638                },
639            },
640            PlacementModifier::Biome,
641        ],
642    },
643    id: OnceLock::new(),
644});
645pub static CRIMSON_FOREST_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
646    key: Identifier::vanilla_static("crimson_forest_vegetation"),
647    data: PlacedFeatureData {
648        feature: ConfiguredFeatureRef::Reference(
649            &crate::vanilla_configured_features::CRIMSON_FOREST_VEGETATION,
650        ),
651        placement: vec![
652            PlacementModifier::CountOnEveryLayer {
653                count: IntProvider::Constant(6i32),
654            },
655            PlacementModifier::Biome,
656        ],
657    },
658    id: OnceLock::new(),
659});
660pub static CRIMSON_FUNGI: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
661    key: Identifier::vanilla_static("crimson_fungi"),
662    data: PlacedFeatureData {
663        feature: ConfiguredFeatureRef::Reference(
664            &crate::vanilla_configured_features::CRIMSON_FUNGUS,
665        ),
666        placement: vec![
667            PlacementModifier::CountOnEveryLayer {
668                count: IntProvider::Constant(8i32),
669            },
670            PlacementModifier::Biome,
671        ],
672    },
673    id: OnceLock::new(),
674});
675pub static DARK_FOREST_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
676    key: Identifier::vanilla_static("dark_forest_vegetation"),
677    data: PlacedFeatureData {
678        feature: ConfiguredFeatureRef::Reference(
679            &crate::vanilla_configured_features::DARK_FOREST_VEGETATION,
680        ),
681        placement: vec![
682            PlacementModifier::Count {
683                count: IntProvider::Constant(16i32),
684            },
685            PlacementModifier::InSquare,
686            PlacementModifier::SurfaceWaterDepthFilter {
687                max_water_depth: 0i32,
688            },
689            PlacementModifier::Heightmap {
690                heightmap: FeatureHeightmap::OceanFloor,
691            },
692            PlacementModifier::Biome,
693        ],
694    },
695    id: OnceLock::new(),
696});
697pub static DARK_OAK_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
698    key: Identifier::vanilla_static("dark_oak_checked"),
699    data: PlacedFeatureData {
700        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DARK_OAK),
701        placement: vec![PlacementModifier::BlockPredicateFilter {
702            predicate: BlockPredicate::WouldSurvive {
703                state: BlockStateData {
704                    block: &vanilla_blocks::DARK_OAK_SAPLING,
705                    properties: &[("stage", "0")],
706                },
707                offset: [0i32, 0i32, 0i32],
708            },
709        }],
710    },
711    id: OnceLock::new(),
712});
713pub static DARK_OAK_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
714    key: Identifier::vanilla_static("dark_oak_leaf_litter"),
715    data: PlacedFeatureData {
716        feature: ConfiguredFeatureRef::Reference(
717            &crate::vanilla_configured_features::DARK_OAK_LEAF_LITTER,
718        ),
719        placement: vec![PlacementModifier::BlockPredicateFilter {
720            predicate: BlockPredicate::WouldSurvive {
721                state: BlockStateData {
722                    block: &vanilla_blocks::DARK_OAK_SAPLING,
723                    properties: &[("stage", "0")],
724                },
725                offset: [0i32, 0i32, 0i32],
726            },
727        }],
728    },
729    id: OnceLock::new(),
730});
731pub static DELTA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
732    key: Identifier::vanilla_static("delta"),
733    data: PlacedFeatureData {
734        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DELTA),
735        placement: vec![
736            PlacementModifier::CountOnEveryLayer {
737                count: IntProvider::Constant(40i32),
738            },
739            PlacementModifier::Biome,
740        ],
741    },
742    id: OnceLock::new(),
743});
744pub static DESERT_WELL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
745    key: Identifier::vanilla_static("desert_well"),
746    data: PlacedFeatureData {
747        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DESERT_WELL),
748        placement: vec![
749            PlacementModifier::RarityFilter { chance: 1000i32 },
750            PlacementModifier::InSquare,
751            PlacementModifier::Heightmap {
752                heightmap: FeatureHeightmap::MotionBlocking,
753            },
754            PlacementModifier::Biome,
755        ],
756    },
757    id: OnceLock::new(),
758});
759pub static DISK_CLAY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
760    key: Identifier::vanilla_static("disk_clay"),
761    data: PlacedFeatureData {
762        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DISK_CLAY),
763        placement: vec![
764            PlacementModifier::InSquare,
765            PlacementModifier::Heightmap {
766                heightmap: FeatureHeightmap::OceanFloorWg,
767            },
768            PlacementModifier::BlockPredicateFilter {
769                predicate: BlockPredicate::MatchingFluids {
770                    fluids: FluidRefList(vec![&vanilla_fluids::WATER]),
771                    offset: [0i32, 0i32, 0i32],
772                },
773            },
774            PlacementModifier::Biome,
775        ],
776    },
777    id: OnceLock::new(),
778});
779pub static DISK_GRASS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
780    key: Identifier::vanilla_static("disk_grass"),
781    data: PlacedFeatureData {
782        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DISK_GRASS),
783        placement: vec![
784            PlacementModifier::Count {
785                count: IntProvider::Constant(1i32),
786            },
787            PlacementModifier::InSquare,
788            PlacementModifier::Heightmap {
789                heightmap: FeatureHeightmap::OceanFloorWg,
790            },
791            PlacementModifier::RandomOffset {
792                xz_spread: IntProvider::Constant(0i32),
793                y_spread: IntProvider::Constant(-1i32),
794            },
795            PlacementModifier::BlockPredicateFilter {
796                predicate: BlockPredicate::MatchingBlocks {
797                    blocks: BlockRefList(vec![&vanilla_blocks::MUD]),
798                    offset: [0i32, 0i32, 0i32],
799                },
800            },
801            PlacementModifier::Biome,
802        ],
803    },
804    id: OnceLock::new(),
805});
806pub static DISK_GRAVEL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
807    key: Identifier::vanilla_static("disk_gravel"),
808    data: PlacedFeatureData {
809        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DISK_GRAVEL),
810        placement: vec![
811            PlacementModifier::InSquare,
812            PlacementModifier::Heightmap {
813                heightmap: FeatureHeightmap::OceanFloorWg,
814            },
815            PlacementModifier::BlockPredicateFilter {
816                predicate: BlockPredicate::MatchingFluids {
817                    fluids: FluidRefList(vec![&vanilla_fluids::WATER]),
818                    offset: [0i32, 0i32, 0i32],
819                },
820            },
821            PlacementModifier::Biome,
822        ],
823    },
824    id: OnceLock::new(),
825});
826pub static DISK_SAND: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
827    key: Identifier::vanilla_static("disk_sand"),
828    data: PlacedFeatureData {
829        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DISK_SAND),
830        placement: vec![
831            PlacementModifier::Count {
832                count: IntProvider::Constant(3i32),
833            },
834            PlacementModifier::InSquare,
835            PlacementModifier::Heightmap {
836                heightmap: FeatureHeightmap::OceanFloorWg,
837            },
838            PlacementModifier::BlockPredicateFilter {
839                predicate: BlockPredicate::MatchingFluids {
840                    fluids: FluidRefList(vec![&vanilla_fluids::WATER]),
841                    offset: [0i32, 0i32, 0i32],
842                },
843            },
844            PlacementModifier::Biome,
845        ],
846    },
847    id: OnceLock::new(),
848});
849pub static DRIPSTONE_CLUSTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
850    key: Identifier::vanilla_static("dripstone_cluster"),
851    data: PlacedFeatureData {
852        feature: ConfiguredFeatureRef::Reference(
853            &crate::vanilla_configured_features::DRIPSTONE_CLUSTER,
854        ),
855        placement: vec![
856            PlacementModifier::Count {
857                count: IntProvider::Uniform {
858                    min_inclusive: 48i32,
859                    max_inclusive: 96i32,
860                },
861            },
862            PlacementModifier::InSquare,
863            PlacementModifier::HeightRange {
864                height: HeightProvider::Uniform {
865                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
866                    max_inclusive: VerticalAnchor::Absolute(256i32),
867                },
868            },
869            PlacementModifier::Biome,
870        ],
871    },
872    id: OnceLock::new(),
873});
874pub static END_GATEWAY_RETURN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
875    key: Identifier::vanilla_static("end_gateway_return"),
876    data: PlacedFeatureData {
877        feature: ConfiguredFeatureRef::Reference(
878            &crate::vanilla_configured_features::END_GATEWAY_RETURN,
879        ),
880        placement: vec![
881            PlacementModifier::RarityFilter { chance: 700i32 },
882            PlacementModifier::InSquare,
883            PlacementModifier::Heightmap {
884                heightmap: FeatureHeightmap::MotionBlocking,
885            },
886            PlacementModifier::RandomOffset {
887                xz_spread: IntProvider::Constant(0i32),
888                y_spread: IntProvider::Uniform {
889                    min_inclusive: 3i32,
890                    max_inclusive: 9i32,
891                },
892            },
893            PlacementModifier::Biome,
894        ],
895    },
896    id: OnceLock::new(),
897});
898pub static END_ISLAND_DECORATED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
899    key: Identifier::vanilla_static("end_island_decorated"),
900    data: PlacedFeatureData {
901        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::END_ISLAND),
902        placement: vec![
903            PlacementModifier::RarityFilter { chance: 14i32 },
904            PlacementModifier::Count {
905                count: IntProvider::WeightedList {
906                    distribution: vec![
907                        WeightedIntProvider {
908                            data: IntProvider::Constant(1i32),
909                            weight: 3i32,
910                        },
911                        WeightedIntProvider {
912                            data: IntProvider::Constant(2i32),
913                            weight: 1i32,
914                        },
915                    ],
916                },
917            },
918            PlacementModifier::InSquare,
919            PlacementModifier::HeightRange {
920                height: HeightProvider::Uniform {
921                    min_inclusive: VerticalAnchor::Absolute(55i32),
922                    max_inclusive: VerticalAnchor::Absolute(70i32),
923                },
924            },
925            PlacementModifier::Biome,
926        ],
927    },
928    id: OnceLock::new(),
929});
930pub static END_PLATFORM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
931    key: Identifier::vanilla_static("end_platform"),
932    data: PlacedFeatureData {
933        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::END_PLATFORM),
934        placement: vec![
935            PlacementModifier::FixedPlacement {
936                positions: vec![[100i32, 49i32, 0i32]],
937            },
938            PlacementModifier::Biome,
939        ],
940    },
941    id: OnceLock::new(),
942});
943pub static END_SPIKE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
944    key: Identifier::vanilla_static("end_spike"),
945    data: PlacedFeatureData {
946        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::END_SPIKE),
947        placement: vec![PlacementModifier::Biome],
948    },
949    id: OnceLock::new(),
950});
951pub static FALLEN_BIRCH_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
952    key: Identifier::vanilla_static("fallen_birch_tree"),
953    data: PlacedFeatureData {
954        feature: ConfiguredFeatureRef::Reference(
955            &crate::vanilla_configured_features::FALLEN_BIRCH_TREE,
956        ),
957        placement: vec![PlacementModifier::BlockPredicateFilter {
958            predicate: BlockPredicate::WouldSurvive {
959                state: BlockStateData {
960                    block: &vanilla_blocks::BIRCH_SAPLING,
961                    properties: &[("stage", "0")],
962                },
963                offset: [0i32, 0i32, 0i32],
964            },
965        }],
966    },
967    id: OnceLock::new(),
968});
969pub static FALLEN_JUNGLE_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
970    key: Identifier::vanilla_static("fallen_jungle_tree"),
971    data: PlacedFeatureData {
972        feature: ConfiguredFeatureRef::Reference(
973            &crate::vanilla_configured_features::FALLEN_JUNGLE_TREE,
974        ),
975        placement: vec![PlacementModifier::BlockPredicateFilter {
976            predicate: BlockPredicate::WouldSurvive {
977                state: BlockStateData {
978                    block: &vanilla_blocks::JUNGLE_SAPLING,
979                    properties: &[("stage", "0")],
980                },
981                offset: [0i32, 0i32, 0i32],
982            },
983        }],
984    },
985    id: OnceLock::new(),
986});
987pub static FALLEN_OAK_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
988    key: Identifier::vanilla_static("fallen_oak_tree"),
989    data: PlacedFeatureData {
990        feature: ConfiguredFeatureRef::Reference(
991            &crate::vanilla_configured_features::FALLEN_OAK_TREE,
992        ),
993        placement: vec![PlacementModifier::BlockPredicateFilter {
994            predicate: BlockPredicate::WouldSurvive {
995                state: BlockStateData {
996                    block: &vanilla_blocks::OAK_SAPLING,
997                    properties: &[("stage", "0")],
998                },
999                offset: [0i32, 0i32, 0i32],
1000            },
1001        }],
1002    },
1003    id: OnceLock::new(),
1004});
1005pub static FALLEN_SPRUCE_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1006    key: Identifier::vanilla_static("fallen_spruce_tree"),
1007    data: PlacedFeatureData {
1008        feature: ConfiguredFeatureRef::Reference(
1009            &crate::vanilla_configured_features::FALLEN_SPRUCE_TREE,
1010        ),
1011        placement: vec![PlacementModifier::BlockPredicateFilter {
1012            predicate: BlockPredicate::WouldSurvive {
1013                state: BlockStateData {
1014                    block: &vanilla_blocks::SPRUCE_SAPLING,
1015                    properties: &[("stage", "0")],
1016                },
1017                offset: [0i32, 0i32, 0i32],
1018            },
1019        }],
1020    },
1021    id: OnceLock::new(),
1022});
1023pub static FALLEN_SUPER_BIRCH_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1024    key: Identifier::vanilla_static("fallen_super_birch_tree"),
1025    data: PlacedFeatureData {
1026        feature: ConfiguredFeatureRef::Reference(
1027            &crate::vanilla_configured_features::FALLEN_SUPER_BIRCH_TREE,
1028        ),
1029        placement: vec![PlacementModifier::BlockPredicateFilter {
1030            predicate: BlockPredicate::WouldSurvive {
1031                state: BlockStateData {
1032                    block: &vanilla_blocks::BIRCH_SAPLING,
1033                    properties: &[("stage", "0")],
1034                },
1035                offset: [0i32, 0i32, 0i32],
1036            },
1037        }],
1038    },
1039    id: OnceLock::new(),
1040});
1041pub static FANCY_OAK_BEES: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1042    key: Identifier::vanilla_static("fancy_oak_bees"),
1043    data: PlacedFeatureData {
1044        feature: ConfiguredFeatureRef::Reference(
1045            &crate::vanilla_configured_features::FANCY_OAK_BEES,
1046        ),
1047        placement: vec![PlacementModifier::BlockPredicateFilter {
1048            predicate: BlockPredicate::WouldSurvive {
1049                state: BlockStateData {
1050                    block: &vanilla_blocks::OAK_SAPLING,
1051                    properties: &[("stage", "0")],
1052                },
1053                offset: [0i32, 0i32, 0i32],
1054            },
1055        }],
1056    },
1057    id: OnceLock::new(),
1058});
1059pub static FANCY_OAK_BEES_0002_LEAF_LITTER: LazyLock<PlacedFeature> =
1060    LazyLock::new(|| PlacedFeature {
1061        key: Identifier::vanilla_static("fancy_oak_bees_0002_leaf_litter"),
1062        data: PlacedFeatureData {
1063            feature: ConfiguredFeatureRef::Reference(
1064                &crate::vanilla_configured_features::FANCY_OAK_BEES_0002_LEAF_LITTER,
1065            ),
1066            placement: vec![PlacementModifier::BlockPredicateFilter {
1067                predicate: BlockPredicate::WouldSurvive {
1068                    state: BlockStateData {
1069                        block: &vanilla_blocks::OAK_SAPLING,
1070                        properties: &[("stage", "0")],
1071                    },
1072                    offset: [0i32, 0i32, 0i32],
1073                },
1074            }],
1075        },
1076        id: OnceLock::new(),
1077    });
1078pub static FANCY_OAK_BEES_002: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1079    key: Identifier::vanilla_static("fancy_oak_bees_002"),
1080    data: PlacedFeatureData {
1081        feature: ConfiguredFeatureRef::Reference(
1082            &crate::vanilla_configured_features::FANCY_OAK_BEES_002,
1083        ),
1084        placement: vec![PlacementModifier::BlockPredicateFilter {
1085            predicate: BlockPredicate::WouldSurvive {
1086                state: BlockStateData {
1087                    block: &vanilla_blocks::OAK_SAPLING,
1088                    properties: &[("stage", "0")],
1089                },
1090                offset: [0i32, 0i32, 0i32],
1091            },
1092        }],
1093    },
1094    id: OnceLock::new(),
1095});
1096pub static FANCY_OAK_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1097    key: Identifier::vanilla_static("fancy_oak_checked"),
1098    data: PlacedFeatureData {
1099        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FANCY_OAK),
1100        placement: vec![PlacementModifier::BlockPredicateFilter {
1101            predicate: BlockPredicate::WouldSurvive {
1102                state: BlockStateData {
1103                    block: &vanilla_blocks::OAK_SAPLING,
1104                    properties: &[("stage", "0")],
1105                },
1106                offset: [0i32, 0i32, 0i32],
1107            },
1108        }],
1109    },
1110    id: OnceLock::new(),
1111});
1112pub static FANCY_OAK_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1113    key: Identifier::vanilla_static("fancy_oak_leaf_litter"),
1114    data: PlacedFeatureData {
1115        feature: ConfiguredFeatureRef::Reference(
1116            &crate::vanilla_configured_features::FANCY_OAK_LEAF_LITTER,
1117        ),
1118        placement: vec![PlacementModifier::BlockPredicateFilter {
1119            predicate: BlockPredicate::WouldSurvive {
1120                state: BlockStateData {
1121                    block: &vanilla_blocks::OAK_SAPLING,
1122                    properties: &[("stage", "0")],
1123                },
1124                offset: [0i32, 0i32, 0i32],
1125            },
1126        }],
1127    },
1128    id: OnceLock::new(),
1129});
1130pub static FLOWER_CHERRY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1131    key: Identifier::vanilla_static("flower_cherry"),
1132    data: PlacedFeatureData {
1133        feature: ConfiguredFeatureRef::Reference(
1134            &crate::vanilla_configured_features::FLOWER_CHERRY,
1135        ),
1136        placement: vec![
1137            PlacementModifier::NoiseThresholdCount {
1138                noise_level: -0.8f64,
1139                below_noise: 5i32,
1140                above_noise: 10i32,
1141            },
1142            PlacementModifier::InSquare,
1143            PlacementModifier::Heightmap {
1144                heightmap: FeatureHeightmap::MotionBlocking,
1145            },
1146            PlacementModifier::Biome,
1147            PlacementModifier::Count {
1148                count: IntProvider::Constant(96i32),
1149            },
1150            PlacementModifier::RandomOffset {
1151                xz_spread: IntProvider::Trapezoid {
1152                    min: -6i32,
1153                    max: 6i32,
1154                    plateau: 0i32,
1155                },
1156                y_spread: IntProvider::Trapezoid {
1157                    min: -2i32,
1158                    max: 2i32,
1159                    plateau: 0i32,
1160                },
1161            },
1162            PlacementModifier::BlockPredicateFilter {
1163                predicate: BlockPredicate::MatchingBlockTag {
1164                    tag: Identifier::vanilla_static("air"),
1165                    offset: [0i32, 0i32, 0i32],
1166                },
1167            },
1168        ],
1169    },
1170    id: OnceLock::new(),
1171});
1172pub static FLOWER_DEFAULT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1173    key: Identifier::vanilla_static("flower_default"),
1174    data: PlacedFeatureData {
1175        feature: ConfiguredFeatureRef::Reference(
1176            &crate::vanilla_configured_features::FLOWER_DEFAULT,
1177        ),
1178        placement: vec![
1179            PlacementModifier::RarityFilter { chance: 32i32 },
1180            PlacementModifier::InSquare,
1181            PlacementModifier::Heightmap {
1182                heightmap: FeatureHeightmap::MotionBlocking,
1183            },
1184            PlacementModifier::Biome,
1185        ],
1186    },
1187    id: OnceLock::new(),
1188});
1189pub static FLOWER_FLOWER_FOREST: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1190    key: Identifier::vanilla_static("flower_flower_forest"),
1191    data: PlacedFeatureData {
1192        feature: ConfiguredFeatureRef::Reference(
1193            &crate::vanilla_configured_features::FLOWER_FLOWER_FOREST,
1194        ),
1195        placement: vec![
1196            PlacementModifier::Count {
1197                count: IntProvider::Constant(3i32),
1198            },
1199            PlacementModifier::RarityFilter { chance: 2i32 },
1200            PlacementModifier::InSquare,
1201            PlacementModifier::Heightmap {
1202                heightmap: FeatureHeightmap::MotionBlocking,
1203            },
1204            PlacementModifier::Biome,
1205            PlacementModifier::Count {
1206                count: IntProvider::Constant(96i32),
1207            },
1208            PlacementModifier::RandomOffset {
1209                xz_spread: IntProvider::Trapezoid {
1210                    min: -6i32,
1211                    max: 6i32,
1212                    plateau: 0i32,
1213                },
1214                y_spread: IntProvider::Trapezoid {
1215                    min: -2i32,
1216                    max: 2i32,
1217                    plateau: 0i32,
1218                },
1219            },
1220            PlacementModifier::BlockPredicateFilter {
1221                predicate: BlockPredicate::MatchingBlockTag {
1222                    tag: Identifier::vanilla_static("air"),
1223                    offset: [0i32, 0i32, 0i32],
1224                },
1225            },
1226        ],
1227    },
1228    id: OnceLock::new(),
1229});
1230pub static FLOWER_FOREST_FLOWERS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1231    key: Identifier::vanilla_static("flower_forest_flowers"),
1232    data: PlacedFeatureData {
1233        feature: ConfiguredFeatureRef::Reference(
1234            &crate::vanilla_configured_features::FOREST_FLOWERS,
1235        ),
1236        placement: vec![
1237            PlacementModifier::RarityFilter { chance: 7i32 },
1238            PlacementModifier::InSquare,
1239            PlacementModifier::Heightmap {
1240                heightmap: FeatureHeightmap::MotionBlocking,
1241            },
1242            PlacementModifier::Count {
1243                count: IntProvider::Clamped {
1244                    source: Box::new(IntProvider::Uniform {
1245                        min_inclusive: -1i32,
1246                        max_inclusive: 3i32,
1247                    }),
1248                    min_inclusive: 0i32,
1249                    max_inclusive: 3i32,
1250                },
1251            },
1252            PlacementModifier::Biome,
1253        ],
1254    },
1255    id: OnceLock::new(),
1256});
1257pub static FLOWER_MEADOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1258    key: Identifier::vanilla_static("flower_meadow"),
1259    data: PlacedFeatureData {
1260        feature: ConfiguredFeatureRef::Reference(
1261            &crate::vanilla_configured_features::FLOWER_MEADOW,
1262        ),
1263        placement: vec![
1264            PlacementModifier::InSquare,
1265            PlacementModifier::Heightmap {
1266                heightmap: FeatureHeightmap::MotionBlocking,
1267            },
1268            PlacementModifier::Biome,
1269            PlacementModifier::Count {
1270                count: IntProvider::Constant(96i32),
1271            },
1272            PlacementModifier::RandomOffset {
1273                xz_spread: IntProvider::Trapezoid {
1274                    min: -6i32,
1275                    max: 6i32,
1276                    plateau: 0i32,
1277                },
1278                y_spread: IntProvider::Trapezoid {
1279                    min: -2i32,
1280                    max: 2i32,
1281                    plateau: 0i32,
1282                },
1283            },
1284            PlacementModifier::BlockPredicateFilter {
1285                predicate: BlockPredicate::MatchingBlockTag {
1286                    tag: Identifier::vanilla_static("air"),
1287                    offset: [0i32, 0i32, 0i32],
1288                },
1289            },
1290        ],
1291    },
1292    id: OnceLock::new(),
1293});
1294pub static FLOWER_PALE_GARDEN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1295    key: Identifier::vanilla_static("flower_pale_garden"),
1296    data: PlacedFeatureData {
1297        feature: ConfiguredFeatureRef::Reference(
1298            &crate::vanilla_configured_features::FLOWER_PALE_GARDEN,
1299        ),
1300        placement: vec![
1301            PlacementModifier::RarityFilter { chance: 32i32 },
1302            PlacementModifier::InSquare,
1303            PlacementModifier::Heightmap {
1304                heightmap: FeatureHeightmap::MotionBlocking,
1305            },
1306            PlacementModifier::Biome,
1307        ],
1308    },
1309    id: OnceLock::new(),
1310});
1311pub static FLOWER_PLAIN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1312    key: Identifier::vanilla_static("flower_plain"),
1313    data: PlacedFeatureData {
1314        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FLOWER_PLAIN),
1315        placement: vec![
1316            PlacementModifier::Count {
1317                count: IntProvider::Constant(64i32),
1318            },
1319            PlacementModifier::RandomOffset {
1320                xz_spread: IntProvider::Trapezoid {
1321                    min: -6i32,
1322                    max: 6i32,
1323                    plateau: 0i32,
1324                },
1325                y_spread: IntProvider::Trapezoid {
1326                    min: -2i32,
1327                    max: 2i32,
1328                    plateau: 0i32,
1329                },
1330            },
1331            PlacementModifier::BlockPredicateFilter {
1332                predicate: BlockPredicate::MatchingBlockTag {
1333                    tag: Identifier::vanilla_static("air"),
1334                    offset: [0i32, 0i32, 0i32],
1335                },
1336            },
1337        ],
1338    },
1339    id: OnceLock::new(),
1340});
1341pub static FLOWER_PLAINS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1342    key: Identifier::vanilla_static("flower_plains"),
1343    data: PlacedFeatureData {
1344        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FLOWER_PLAIN),
1345        placement: vec![
1346            PlacementModifier::NoiseThresholdCount {
1347                noise_level: -0.8f64,
1348                below_noise: 15i32,
1349                above_noise: 4i32,
1350            },
1351            PlacementModifier::RarityFilter { chance: 32i32 },
1352            PlacementModifier::InSquare,
1353            PlacementModifier::Heightmap {
1354                heightmap: FeatureHeightmap::MotionBlocking,
1355            },
1356            PlacementModifier::Biome,
1357            PlacementModifier::Count {
1358                count: IntProvider::Constant(64i32),
1359            },
1360            PlacementModifier::RandomOffset {
1361                xz_spread: IntProvider::Trapezoid {
1362                    min: -6i32,
1363                    max: 6i32,
1364                    plateau: 0i32,
1365                },
1366                y_spread: IntProvider::Trapezoid {
1367                    min: -2i32,
1368                    max: 2i32,
1369                    plateau: 0i32,
1370                },
1371            },
1372            PlacementModifier::BlockPredicateFilter {
1373                predicate: BlockPredicate::MatchingBlockTag {
1374                    tag: Identifier::vanilla_static("air"),
1375                    offset: [0i32, 0i32, 0i32],
1376                },
1377            },
1378        ],
1379    },
1380    id: OnceLock::new(),
1381});
1382pub static FLOWER_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1383    key: Identifier::vanilla_static("flower_swamp"),
1384    data: PlacedFeatureData {
1385        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FLOWER_SWAMP),
1386        placement: vec![
1387            PlacementModifier::RarityFilter { chance: 32i32 },
1388            PlacementModifier::InSquare,
1389            PlacementModifier::Heightmap {
1390                heightmap: FeatureHeightmap::MotionBlocking,
1391            },
1392            PlacementModifier::Biome,
1393            PlacementModifier::Count {
1394                count: IntProvider::Constant(64i32),
1395            },
1396            PlacementModifier::RandomOffset {
1397                xz_spread: IntProvider::Trapezoid {
1398                    min: -6i32,
1399                    max: 6i32,
1400                    plateau: 0i32,
1401                },
1402                y_spread: IntProvider::Trapezoid {
1403                    min: -2i32,
1404                    max: 2i32,
1405                    plateau: 0i32,
1406                },
1407            },
1408            PlacementModifier::BlockPredicateFilter {
1409                predicate: BlockPredicate::MatchingBlockTag {
1410                    tag: Identifier::vanilla_static("air"),
1411                    offset: [0i32, 0i32, 0i32],
1412                },
1413            },
1414        ],
1415    },
1416    id: OnceLock::new(),
1417});
1418pub static FLOWER_WARM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1419    key: Identifier::vanilla_static("flower_warm"),
1420    data: PlacedFeatureData {
1421        feature: ConfiguredFeatureRef::Reference(
1422            &crate::vanilla_configured_features::FLOWER_DEFAULT,
1423        ),
1424        placement: vec![
1425            PlacementModifier::RarityFilter { chance: 16i32 },
1426            PlacementModifier::InSquare,
1427            PlacementModifier::Heightmap {
1428                heightmap: FeatureHeightmap::MotionBlocking,
1429            },
1430            PlacementModifier::Biome,
1431        ],
1432    },
1433    id: OnceLock::new(),
1434});
1435pub static FOREST_FLOWERS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1436    key: Identifier::vanilla_static("forest_flowers"),
1437    data: PlacedFeatureData {
1438        feature: ConfiguredFeatureRef::Reference(
1439            &crate::vanilla_configured_features::FOREST_FLOWERS,
1440        ),
1441        placement: vec![
1442            PlacementModifier::RarityFilter { chance: 7i32 },
1443            PlacementModifier::InSquare,
1444            PlacementModifier::Heightmap {
1445                heightmap: FeatureHeightmap::MotionBlocking,
1446            },
1447            PlacementModifier::Count {
1448                count: IntProvider::Clamped {
1449                    source: Box::new(IntProvider::Uniform {
1450                        min_inclusive: -3i32,
1451                        max_inclusive: 1i32,
1452                    }),
1453                    min_inclusive: 0i32,
1454                    max_inclusive: 1i32,
1455                },
1456            },
1457            PlacementModifier::Biome,
1458        ],
1459    },
1460    id: OnceLock::new(),
1461});
1462pub static FOREST_ROCK: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1463    key: Identifier::vanilla_static("forest_rock"),
1464    data: PlacedFeatureData {
1465        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FOREST_ROCK),
1466        placement: vec![
1467            PlacementModifier::Count {
1468                count: IntProvider::Constant(2i32),
1469            },
1470            PlacementModifier::InSquare,
1471            PlacementModifier::Heightmap {
1472                heightmap: FeatureHeightmap::MotionBlocking,
1473            },
1474            PlacementModifier::Biome,
1475        ],
1476    },
1477    id: OnceLock::new(),
1478});
1479pub static FOSSIL_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1480    key: Identifier::vanilla_static("fossil_lower"),
1481    data: PlacedFeatureData {
1482        feature: ConfiguredFeatureRef::Reference(
1483            &crate::vanilla_configured_features::FOSSIL_DIAMONDS,
1484        ),
1485        placement: vec![
1486            PlacementModifier::RarityFilter { chance: 64i32 },
1487            PlacementModifier::InSquare,
1488            PlacementModifier::HeightRange {
1489                height: HeightProvider::Uniform {
1490                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
1491                    max_inclusive: VerticalAnchor::Absolute(-8i32),
1492                },
1493            },
1494            PlacementModifier::Biome,
1495        ],
1496    },
1497    id: OnceLock::new(),
1498});
1499pub static FOSSIL_UPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1500    key: Identifier::vanilla_static("fossil_upper"),
1501    data: PlacedFeatureData {
1502        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FOSSIL_COAL),
1503        placement: vec![
1504            PlacementModifier::RarityFilter { chance: 64i32 },
1505            PlacementModifier::InSquare,
1506            PlacementModifier::HeightRange {
1507                height: HeightProvider::Uniform {
1508                    min_inclusive: VerticalAnchor::Absolute(0i32),
1509                    max_inclusive: VerticalAnchor::BelowTop(0i32),
1510                },
1511            },
1512            PlacementModifier::Biome,
1513        ],
1514    },
1515    id: OnceLock::new(),
1516});
1517pub static FREEZE_TOP_LAYER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1518    key: Identifier::vanilla_static("freeze_top_layer"),
1519    data: PlacedFeatureData {
1520        feature: ConfiguredFeatureRef::Reference(
1521            &crate::vanilla_configured_features::FREEZE_TOP_LAYER,
1522        ),
1523        placement: vec![PlacementModifier::Biome],
1524    },
1525    id: OnceLock::new(),
1526});
1527pub static GLOW_LICHEN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1528    key: Identifier::vanilla_static("glow_lichen"),
1529    data: PlacedFeatureData {
1530        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GLOW_LICHEN),
1531        placement: vec![
1532            PlacementModifier::Count {
1533                count: IntProvider::Uniform {
1534                    min_inclusive: 104i32,
1535                    max_inclusive: 157i32,
1536                },
1537            },
1538            PlacementModifier::HeightRange {
1539                height: HeightProvider::Uniform {
1540                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
1541                    max_inclusive: VerticalAnchor::Absolute(256i32),
1542                },
1543            },
1544            PlacementModifier::InSquare,
1545            PlacementModifier::SurfaceRelativeThresholdFilter {
1546                heightmap: FeatureHeightmap::OceanFloorWg,
1547                min_inclusive: None,
1548                max_inclusive: Some(-13i32),
1549            },
1550            PlacementModifier::Biome,
1551        ],
1552    },
1553    id: OnceLock::new(),
1554});
1555pub static GLOWSTONE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1556    key: Identifier::vanilla_static("glowstone"),
1557    data: PlacedFeatureData {
1558        feature: ConfiguredFeatureRef::Reference(
1559            &crate::vanilla_configured_features::GLOWSTONE_EXTRA,
1560        ),
1561        placement: vec![
1562            PlacementModifier::Count {
1563                count: IntProvider::Constant(10i32),
1564            },
1565            PlacementModifier::InSquare,
1566            PlacementModifier::HeightRange {
1567                height: HeightProvider::Uniform {
1568                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
1569                    max_inclusive: VerticalAnchor::BelowTop(0i32),
1570                },
1571            },
1572            PlacementModifier::Biome,
1573        ],
1574    },
1575    id: OnceLock::new(),
1576});
1577pub static GLOWSTONE_EXTRA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1578    key: Identifier::vanilla_static("glowstone_extra"),
1579    data: PlacedFeatureData {
1580        feature: ConfiguredFeatureRef::Reference(
1581            &crate::vanilla_configured_features::GLOWSTONE_EXTRA,
1582        ),
1583        placement: vec![
1584            PlacementModifier::Count {
1585                count: IntProvider::BiasedToBottom {
1586                    min_inclusive: 0i32,
1587                    max_inclusive: 9i32,
1588                },
1589            },
1590            PlacementModifier::InSquare,
1591            PlacementModifier::HeightRange {
1592                height: HeightProvider::Uniform {
1593                    min_inclusive: VerticalAnchor::AboveBottom(4i32),
1594                    max_inclusive: VerticalAnchor::BelowTop(4i32),
1595                },
1596            },
1597            PlacementModifier::Biome,
1598        ],
1599    },
1600    id: OnceLock::new(),
1601});
1602pub static GRASS_BONEMEAL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1603    key: Identifier::vanilla_static("grass_bonemeal"),
1604    data: PlacedFeatureData {
1605        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
1606        placement: vec![PlacementModifier::BlockPredicateFilter {
1607            predicate: BlockPredicate::MatchingBlockTag {
1608                tag: Identifier::vanilla_static("air"),
1609                offset: [0i32, 0i32, 0i32],
1610            },
1611        }],
1612    },
1613    id: OnceLock::new(),
1614});
1615pub static ICE_PATCH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1616    key: Identifier::vanilla_static("ice_patch"),
1617    data: PlacedFeatureData {
1618        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ICE_PATCH),
1619        placement: vec![
1620            PlacementModifier::Count {
1621                count: IntProvider::Constant(2i32),
1622            },
1623            PlacementModifier::InSquare,
1624            PlacementModifier::Heightmap {
1625                heightmap: FeatureHeightmap::MotionBlocking,
1626            },
1627            PlacementModifier::RandomOffset {
1628                xz_spread: IntProvider::Constant(0i32),
1629                y_spread: IntProvider::Constant(-1i32),
1630            },
1631            PlacementModifier::BlockPredicateFilter {
1632                predicate: BlockPredicate::MatchingBlocks {
1633                    blocks: BlockRefList(vec![&vanilla_blocks::SNOW_BLOCK]),
1634                    offset: [0i32, 0i32, 0i32],
1635                },
1636            },
1637            PlacementModifier::Biome,
1638        ],
1639    },
1640    id: OnceLock::new(),
1641});
1642pub static ICE_SPIKE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1643    key: Identifier::vanilla_static("ice_spike"),
1644    data: PlacedFeatureData {
1645        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ICE_SPIKE),
1646        placement: vec![
1647            PlacementModifier::Count {
1648                count: IntProvider::Constant(3i32),
1649            },
1650            PlacementModifier::InSquare,
1651            PlacementModifier::Heightmap {
1652                heightmap: FeatureHeightmap::MotionBlocking,
1653            },
1654            PlacementModifier::Biome,
1655        ],
1656    },
1657    id: OnceLock::new(),
1658});
1659pub static ICEBERG_BLUE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1660    key: Identifier::vanilla_static("iceberg_blue"),
1661    data: PlacedFeatureData {
1662        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ICEBERG_BLUE),
1663        placement: vec![
1664            PlacementModifier::RarityFilter { chance: 200i32 },
1665            PlacementModifier::InSquare,
1666            PlacementModifier::Biome,
1667        ],
1668    },
1669    id: OnceLock::new(),
1670});
1671pub static ICEBERG_PACKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1672    key: Identifier::vanilla_static("iceberg_packed"),
1673    data: PlacedFeatureData {
1674        feature: ConfiguredFeatureRef::Reference(
1675            &crate::vanilla_configured_features::ICEBERG_PACKED,
1676        ),
1677        placement: vec![
1678            PlacementModifier::RarityFilter { chance: 16i32 },
1679            PlacementModifier::InSquare,
1680            PlacementModifier::Biome,
1681        ],
1682    },
1683    id: OnceLock::new(),
1684});
1685pub static JUNGLE_BUSH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1686    key: Identifier::vanilla_static("jungle_bush"),
1687    data: PlacedFeatureData {
1688        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::JUNGLE_BUSH),
1689        placement: vec![PlacementModifier::BlockPredicateFilter {
1690            predicate: BlockPredicate::WouldSurvive {
1691                state: BlockStateData {
1692                    block: &vanilla_blocks::OAK_SAPLING,
1693                    properties: &[("stage", "0")],
1694                },
1695                offset: [0i32, 0i32, 0i32],
1696            },
1697        }],
1698    },
1699    id: OnceLock::new(),
1700});
1701pub static JUNGLE_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1702    key: Identifier::vanilla_static("jungle_tree"),
1703    data: PlacedFeatureData {
1704        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::JUNGLE_TREE),
1705        placement: vec![PlacementModifier::BlockPredicateFilter {
1706            predicate: BlockPredicate::WouldSurvive {
1707                state: BlockStateData {
1708                    block: &vanilla_blocks::JUNGLE_SAPLING,
1709                    properties: &[("stage", "0")],
1710                },
1711                offset: [0i32, 0i32, 0i32],
1712            },
1713        }],
1714    },
1715    id: OnceLock::new(),
1716});
1717pub static KELP_COLD: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1718    key: Identifier::vanilla_static("kelp_cold"),
1719    data: PlacedFeatureData {
1720        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::KELP),
1721        placement: vec![
1722            PlacementModifier::NoiseBasedCount {
1723                noise_to_count_ratio: 120i32,
1724                noise_factor: 80f64,
1725                noise_offset: 0f64,
1726            },
1727            PlacementModifier::InSquare,
1728            PlacementModifier::Heightmap {
1729                heightmap: FeatureHeightmap::OceanFloorWg,
1730            },
1731            PlacementModifier::Biome,
1732        ],
1733    },
1734    id: OnceLock::new(),
1735});
1736pub static KELP_WARM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1737    key: Identifier::vanilla_static("kelp_warm"),
1738    data: PlacedFeatureData {
1739        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::KELP),
1740        placement: vec![
1741            PlacementModifier::NoiseBasedCount {
1742                noise_to_count_ratio: 80i32,
1743                noise_factor: 80f64,
1744                noise_offset: 0f64,
1745            },
1746            PlacementModifier::InSquare,
1747            PlacementModifier::Heightmap {
1748                heightmap: FeatureHeightmap::OceanFloorWg,
1749            },
1750            PlacementModifier::Biome,
1751        ],
1752    },
1753    id: OnceLock::new(),
1754});
1755pub static LAKE_LAVA_SURFACE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1756    key: Identifier::vanilla_static("lake_lava_surface"),
1757    data: PlacedFeatureData {
1758        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::LAKE_LAVA),
1759        placement: vec![
1760            PlacementModifier::RarityFilter { chance: 200i32 },
1761            PlacementModifier::InSquare,
1762            PlacementModifier::Heightmap {
1763                heightmap: FeatureHeightmap::WorldSurfaceWg,
1764            },
1765            PlacementModifier::Biome,
1766        ],
1767    },
1768    id: OnceLock::new(),
1769});
1770pub static LAKE_LAVA_UNDERGROUND: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1771    key: Identifier::vanilla_static("lake_lava_underground"),
1772    data: PlacedFeatureData {
1773        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::LAKE_LAVA),
1774        placement: vec![
1775            PlacementModifier::RarityFilter { chance: 9i32 },
1776            PlacementModifier::InSquare,
1777            PlacementModifier::HeightRange {
1778                height: HeightProvider::Uniform {
1779                    min_inclusive: VerticalAnchor::Absolute(0i32),
1780                    max_inclusive: VerticalAnchor::BelowTop(0i32),
1781                },
1782            },
1783            PlacementModifier::EnvironmentScan {
1784                direction_of_search: Direction::Down,
1785                target_condition: BlockPredicate::AllOf {
1786                    predicates: vec![
1787                        BlockPredicate::Not {
1788                            predicate: Box::new(BlockPredicate::MatchingBlockTag {
1789                                tag: Identifier::vanilla_static("air"),
1790                                offset: [0i32, 0i32, 0i32],
1791                            }),
1792                        },
1793                        BlockPredicate::InsideWorldBounds {
1794                            offset: [0i32, -5i32, 0i32],
1795                        },
1796                    ],
1797                },
1798                allowed_search_condition: None,
1799                max_steps: 32i32,
1800            },
1801            PlacementModifier::SurfaceRelativeThresholdFilter {
1802                heightmap: FeatureHeightmap::OceanFloorWg,
1803                min_inclusive: None,
1804                max_inclusive: Some(-5i32),
1805            },
1806            PlacementModifier::Biome,
1807        ],
1808    },
1809    id: OnceLock::new(),
1810});
1811pub static LARGE_BASALT_COLUMNS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1812    key: Identifier::vanilla_static("large_basalt_columns"),
1813    data: PlacedFeatureData {
1814        feature: ConfiguredFeatureRef::Reference(
1815            &crate::vanilla_configured_features::LARGE_BASALT_COLUMNS,
1816        ),
1817        placement: vec![
1818            PlacementModifier::CountOnEveryLayer {
1819                count: IntProvider::Constant(2i32),
1820            },
1821            PlacementModifier::Biome,
1822        ],
1823    },
1824    id: OnceLock::new(),
1825});
1826pub static LARGE_DRIPSTONE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1827    key: Identifier::vanilla_static("large_dripstone"),
1828    data: PlacedFeatureData {
1829        feature: ConfiguredFeatureRef::Reference(
1830            &crate::vanilla_configured_features::LARGE_DRIPSTONE,
1831        ),
1832        placement: vec![
1833            PlacementModifier::Count {
1834                count: IntProvider::Uniform {
1835                    min_inclusive: 10i32,
1836                    max_inclusive: 48i32,
1837                },
1838            },
1839            PlacementModifier::InSquare,
1840            PlacementModifier::HeightRange {
1841                height: HeightProvider::Uniform {
1842                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
1843                    max_inclusive: VerticalAnchor::Absolute(256i32),
1844                },
1845            },
1846            PlacementModifier::Biome,
1847        ],
1848    },
1849    id: OnceLock::new(),
1850});
1851pub static LUSH_CAVES_CEILING_VEGETATION: LazyLock<PlacedFeature> =
1852    LazyLock::new(|| PlacedFeature {
1853        key: Identifier::vanilla_static("lush_caves_ceiling_vegetation"),
1854        data: PlacedFeatureData {
1855            feature: ConfiguredFeatureRef::Reference(
1856                &crate::vanilla_configured_features::MOSS_PATCH_CEILING,
1857            ),
1858            placement: vec![
1859                PlacementModifier::Count {
1860                    count: IntProvider::Constant(125i32),
1861                },
1862                PlacementModifier::InSquare,
1863                PlacementModifier::HeightRange {
1864                    height: HeightProvider::Uniform {
1865                        min_inclusive: VerticalAnchor::AboveBottom(0i32),
1866                        max_inclusive: VerticalAnchor::Absolute(256i32),
1867                    },
1868                },
1869                PlacementModifier::EnvironmentScan {
1870                    direction_of_search: Direction::Up,
1871                    target_condition: BlockPredicate::Solid {
1872                        offset: [0i32, 0i32, 0i32],
1873                    },
1874                    allowed_search_condition: Some(BlockPredicate::MatchingBlockTag {
1875                        tag: Identifier::vanilla_static("air"),
1876                        offset: [0i32, 0i32, 0i32],
1877                    }),
1878                    max_steps: 12i32,
1879                },
1880                PlacementModifier::RandomOffset {
1881                    xz_spread: IntProvider::Constant(0i32),
1882                    y_spread: IntProvider::Constant(-1i32),
1883                },
1884                PlacementModifier::Biome,
1885            ],
1886        },
1887        id: OnceLock::new(),
1888    });
1889pub static LUSH_CAVES_CLAY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1890    key: Identifier::vanilla_static("lush_caves_clay"),
1891    data: PlacedFeatureData {
1892        feature: ConfiguredFeatureRef::Reference(
1893            &crate::vanilla_configured_features::LUSH_CAVES_CLAY,
1894        ),
1895        placement: vec![
1896            PlacementModifier::Count {
1897                count: IntProvider::Constant(62i32),
1898            },
1899            PlacementModifier::InSquare,
1900            PlacementModifier::HeightRange {
1901                height: HeightProvider::Uniform {
1902                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
1903                    max_inclusive: VerticalAnchor::Absolute(256i32),
1904                },
1905            },
1906            PlacementModifier::EnvironmentScan {
1907                direction_of_search: Direction::Down,
1908                target_condition: BlockPredicate::Solid {
1909                    offset: [0i32, 0i32, 0i32],
1910                },
1911                allowed_search_condition: Some(BlockPredicate::MatchingBlockTag {
1912                    tag: Identifier::vanilla_static("air"),
1913                    offset: [0i32, 0i32, 0i32],
1914                }),
1915                max_steps: 12i32,
1916            },
1917            PlacementModifier::RandomOffset {
1918                xz_spread: IntProvider::Constant(0i32),
1919                y_spread: IntProvider::Constant(1i32),
1920            },
1921            PlacementModifier::Biome,
1922        ],
1923    },
1924    id: OnceLock::new(),
1925});
1926pub static LUSH_CAVES_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1927    key: Identifier::vanilla_static("lush_caves_vegetation"),
1928    data: PlacedFeatureData {
1929        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MOSS_PATCH),
1930        placement: vec![
1931            PlacementModifier::Count {
1932                count: IntProvider::Constant(125i32),
1933            },
1934            PlacementModifier::InSquare,
1935            PlacementModifier::HeightRange {
1936                height: HeightProvider::Uniform {
1937                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
1938                    max_inclusive: VerticalAnchor::Absolute(256i32),
1939                },
1940            },
1941            PlacementModifier::EnvironmentScan {
1942                direction_of_search: Direction::Down,
1943                target_condition: BlockPredicate::Solid {
1944                    offset: [0i32, 0i32, 0i32],
1945                },
1946                allowed_search_condition: Some(BlockPredicate::MatchingBlockTag {
1947                    tag: Identifier::vanilla_static("air"),
1948                    offset: [0i32, 0i32, 0i32],
1949                }),
1950                max_steps: 12i32,
1951            },
1952            PlacementModifier::RandomOffset {
1953                xz_spread: IntProvider::Constant(0i32),
1954                y_spread: IntProvider::Constant(1i32),
1955            },
1956            PlacementModifier::Biome,
1957        ],
1958    },
1959    id: OnceLock::new(),
1960});
1961pub static MANGROVE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1962    key: Identifier::vanilla_static("mangrove_checked"),
1963    data: PlacedFeatureData {
1964        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MANGROVE),
1965        placement: vec![PlacementModifier::BlockPredicateFilter {
1966            predicate: BlockPredicate::WouldSurvive {
1967                state: BlockStateData {
1968                    block: &vanilla_blocks::MANGROVE_PROPAGULE,
1969                    properties: &[
1970                        ("age", "0"),
1971                        ("hanging", "false"),
1972                        ("stage", "0"),
1973                        ("waterlogged", "false"),
1974                    ],
1975                },
1976                offset: [0i32, 0i32, 0i32],
1977            },
1978        }],
1979    },
1980    id: OnceLock::new(),
1981});
1982pub static MEGA_JUNGLE_TREE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
1983    key: Identifier::vanilla_static("mega_jungle_tree_checked"),
1984    data: PlacedFeatureData {
1985        feature: ConfiguredFeatureRef::Reference(
1986            &crate::vanilla_configured_features::MEGA_JUNGLE_TREE,
1987        ),
1988        placement: vec![PlacementModifier::BlockPredicateFilter {
1989            predicate: BlockPredicate::WouldSurvive {
1990                state: BlockStateData {
1991                    block: &vanilla_blocks::JUNGLE_SAPLING,
1992                    properties: &[("stage", "0")],
1993                },
1994                offset: [0i32, 0i32, 0i32],
1995            },
1996        }],
1997    },
1998    id: OnceLock::new(),
1999});
2000pub static MEGA_PINE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2001    key: Identifier::vanilla_static("mega_pine_checked"),
2002    data: PlacedFeatureData {
2003        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MEGA_PINE),
2004        placement: vec![PlacementModifier::BlockPredicateFilter {
2005            predicate: BlockPredicate::WouldSurvive {
2006                state: BlockStateData {
2007                    block: &vanilla_blocks::SPRUCE_SAPLING,
2008                    properties: &[("stage", "0")],
2009                },
2010                offset: [0i32, 0i32, 0i32],
2011            },
2012        }],
2013    },
2014    id: OnceLock::new(),
2015});
2016pub static MEGA_SPRUCE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2017    key: Identifier::vanilla_static("mega_spruce_checked"),
2018    data: PlacedFeatureData {
2019        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MEGA_SPRUCE),
2020        placement: vec![PlacementModifier::BlockPredicateFilter {
2021            predicate: BlockPredicate::WouldSurvive {
2022                state: BlockStateData {
2023                    block: &vanilla_blocks::SPRUCE_SAPLING,
2024                    properties: &[("stage", "0")],
2025                },
2026                offset: [0i32, 0i32, 0i32],
2027            },
2028        }],
2029    },
2030    id: OnceLock::new(),
2031});
2032pub static MONSTER_ROOM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2033    key: Identifier::vanilla_static("monster_room"),
2034    data: PlacedFeatureData {
2035        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MONSTER_ROOM),
2036        placement: vec![
2037            PlacementModifier::Count {
2038                count: IntProvider::Constant(10i32),
2039            },
2040            PlacementModifier::InSquare,
2041            PlacementModifier::HeightRange {
2042                height: HeightProvider::Uniform {
2043                    min_inclusive: VerticalAnchor::Absolute(0i32),
2044                    max_inclusive: VerticalAnchor::BelowTop(0i32),
2045                },
2046            },
2047            PlacementModifier::Biome,
2048        ],
2049    },
2050    id: OnceLock::new(),
2051});
2052pub static MONSTER_ROOM_DEEP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2053    key: Identifier::vanilla_static("monster_room_deep"),
2054    data: PlacedFeatureData {
2055        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MONSTER_ROOM),
2056        placement: vec![
2057            PlacementModifier::Count {
2058                count: IntProvider::Constant(4i32),
2059            },
2060            PlacementModifier::InSquare,
2061            PlacementModifier::HeightRange {
2062                height: HeightProvider::Uniform {
2063                    min_inclusive: VerticalAnchor::AboveBottom(6i32),
2064                    max_inclusive: VerticalAnchor::Absolute(-1i32),
2065                },
2066            },
2067            PlacementModifier::Biome,
2068        ],
2069    },
2070    id: OnceLock::new(),
2071});
2072pub static MUSHROOM_ISLAND_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2073    key: Identifier::vanilla_static("mushroom_island_vegetation"),
2074    data: PlacedFeatureData {
2075        feature: ConfiguredFeatureRef::Reference(
2076            &crate::vanilla_configured_features::MUSHROOM_ISLAND_VEGETATION,
2077        ),
2078        placement: vec![
2079            PlacementModifier::InSquare,
2080            PlacementModifier::Heightmap {
2081                heightmap: FeatureHeightmap::MotionBlocking,
2082            },
2083            PlacementModifier::Biome,
2084        ],
2085    },
2086    id: OnceLock::new(),
2087});
2088pub static NETHER_SPROUTS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2089    key: Identifier::vanilla_static("nether_sprouts"),
2090    data: PlacedFeatureData {
2091        feature: ConfiguredFeatureRef::Reference(
2092            &crate::vanilla_configured_features::NETHER_SPROUTS,
2093        ),
2094        placement: vec![
2095            PlacementModifier::CountOnEveryLayer {
2096                count: IntProvider::Constant(4i32),
2097            },
2098            PlacementModifier::Biome,
2099        ],
2100    },
2101    id: OnceLock::new(),
2102});
2103pub static OAK: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2104    key: Identifier::vanilla_static("oak"),
2105    data: PlacedFeatureData {
2106        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::OAK),
2107        placement: vec![PlacementModifier::BlockPredicateFilter {
2108            predicate: BlockPredicate::WouldSurvive {
2109                state: BlockStateData {
2110                    block: &vanilla_blocks::OAK_SAPLING,
2111                    properties: &[("stage", "0")],
2112                },
2113                offset: [0i32, 0i32, 0i32],
2114            },
2115        }],
2116    },
2117    id: OnceLock::new(),
2118});
2119pub static OAK_BEES_0002_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2120    key: Identifier::vanilla_static("oak_bees_0002_leaf_litter"),
2121    data: PlacedFeatureData {
2122        feature: ConfiguredFeatureRef::Reference(
2123            &crate::vanilla_configured_features::OAK_BEES_0002_LEAF_LITTER,
2124        ),
2125        placement: vec![PlacementModifier::BlockPredicateFilter {
2126            predicate: BlockPredicate::WouldSurvive {
2127                state: BlockStateData {
2128                    block: &vanilla_blocks::OAK_SAPLING,
2129                    properties: &[("stage", "0")],
2130                },
2131                offset: [0i32, 0i32, 0i32],
2132            },
2133        }],
2134    },
2135    id: OnceLock::new(),
2136});
2137pub static OAK_BEES_002: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2138    key: Identifier::vanilla_static("oak_bees_002"),
2139    data: PlacedFeatureData {
2140        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::OAK_BEES_002),
2141        placement: vec![PlacementModifier::BlockPredicateFilter {
2142            predicate: BlockPredicate::WouldSurvive {
2143                state: BlockStateData {
2144                    block: &vanilla_blocks::OAK_SAPLING,
2145                    properties: &[("stage", "0")],
2146                },
2147                offset: [0i32, 0i32, 0i32],
2148            },
2149        }],
2150    },
2151    id: OnceLock::new(),
2152});
2153pub static OAK_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2154    key: Identifier::vanilla_static("oak_checked"),
2155    data: PlacedFeatureData {
2156        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::OAK),
2157        placement: vec![PlacementModifier::BlockPredicateFilter {
2158            predicate: BlockPredicate::WouldSurvive {
2159                state: BlockStateData {
2160                    block: &vanilla_blocks::OAK_SAPLING,
2161                    properties: &[("stage", "0")],
2162                },
2163                offset: [0i32, 0i32, 0i32],
2164            },
2165        }],
2166    },
2167    id: OnceLock::new(),
2168});
2169pub static OAK_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2170    key: Identifier::vanilla_static("oak_leaf_litter"),
2171    data: PlacedFeatureData {
2172        feature: ConfiguredFeatureRef::Reference(
2173            &crate::vanilla_configured_features::OAK_LEAF_LITTER,
2174        ),
2175        placement: vec![PlacementModifier::BlockPredicateFilter {
2176            predicate: BlockPredicate::WouldSurvive {
2177                state: BlockStateData {
2178                    block: &vanilla_blocks::OAK_SAPLING,
2179                    properties: &[("stage", "0")],
2180                },
2181                offset: [0i32, 0i32, 0i32],
2182            },
2183        }],
2184    },
2185    id: OnceLock::new(),
2186});
2187pub static ORE_ANCIENT_DEBRIS_LARGE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2188    key: Identifier::vanilla_static("ore_ancient_debris_large"),
2189    data: PlacedFeatureData {
2190        feature: ConfiguredFeatureRef::Reference(
2191            &crate::vanilla_configured_features::ORE_ANCIENT_DEBRIS_LARGE,
2192        ),
2193        placement: vec![
2194            PlacementModifier::InSquare,
2195            PlacementModifier::HeightRange {
2196                height: HeightProvider::Trapezoid {
2197                    min_inclusive: VerticalAnchor::Absolute(8i32),
2198                    max_inclusive: VerticalAnchor::Absolute(24i32),
2199                    plateau: 0i32,
2200                },
2201            },
2202            PlacementModifier::Biome,
2203        ],
2204    },
2205    id: OnceLock::new(),
2206});
2207pub static ORE_ANDESITE_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2208    key: Identifier::vanilla_static("ore_andesite_lower"),
2209    data: PlacedFeatureData {
2210        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_ANDESITE),
2211        placement: vec![
2212            PlacementModifier::Count {
2213                count: IntProvider::Constant(2i32),
2214            },
2215            PlacementModifier::InSquare,
2216            PlacementModifier::HeightRange {
2217                height: HeightProvider::Uniform {
2218                    min_inclusive: VerticalAnchor::Absolute(0i32),
2219                    max_inclusive: VerticalAnchor::Absolute(60i32),
2220                },
2221            },
2222            PlacementModifier::Biome,
2223        ],
2224    },
2225    id: OnceLock::new(),
2226});
2227pub static ORE_ANDESITE_UPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2228    key: Identifier::vanilla_static("ore_andesite_upper"),
2229    data: PlacedFeatureData {
2230        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_ANDESITE),
2231        placement: vec![
2232            PlacementModifier::RarityFilter { chance: 6i32 },
2233            PlacementModifier::InSquare,
2234            PlacementModifier::HeightRange {
2235                height: HeightProvider::Uniform {
2236                    min_inclusive: VerticalAnchor::Absolute(64i32),
2237                    max_inclusive: VerticalAnchor::Absolute(128i32),
2238                },
2239            },
2240            PlacementModifier::Biome,
2241        ],
2242    },
2243    id: OnceLock::new(),
2244});
2245pub static ORE_BLACKSTONE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2246    key: Identifier::vanilla_static("ore_blackstone"),
2247    data: PlacedFeatureData {
2248        feature: ConfiguredFeatureRef::Reference(
2249            &crate::vanilla_configured_features::ORE_BLACKSTONE,
2250        ),
2251        placement: vec![
2252            PlacementModifier::Count {
2253                count: IntProvider::Constant(2i32),
2254            },
2255            PlacementModifier::InSquare,
2256            PlacementModifier::HeightRange {
2257                height: HeightProvider::Uniform {
2258                    min_inclusive: VerticalAnchor::Absolute(5i32),
2259                    max_inclusive: VerticalAnchor::Absolute(31i32),
2260                },
2261            },
2262            PlacementModifier::Biome,
2263        ],
2264    },
2265    id: OnceLock::new(),
2266});
2267pub static ORE_CLAY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2268    key: Identifier::vanilla_static("ore_clay"),
2269    data: PlacedFeatureData {
2270        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_CLAY),
2271        placement: vec![
2272            PlacementModifier::Count {
2273                count: IntProvider::Constant(46i32),
2274            },
2275            PlacementModifier::InSquare,
2276            PlacementModifier::HeightRange {
2277                height: HeightProvider::Uniform {
2278                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2279                    max_inclusive: VerticalAnchor::Absolute(256i32),
2280                },
2281            },
2282            PlacementModifier::Biome,
2283        ],
2284    },
2285    id: OnceLock::new(),
2286});
2287pub static ORE_COAL_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2288    key: Identifier::vanilla_static("ore_coal_lower"),
2289    data: PlacedFeatureData {
2290        feature: ConfiguredFeatureRef::Reference(
2291            &crate::vanilla_configured_features::ORE_COAL_BURIED,
2292        ),
2293        placement: vec![
2294            PlacementModifier::Count {
2295                count: IntProvider::Constant(20i32),
2296            },
2297            PlacementModifier::InSquare,
2298            PlacementModifier::HeightRange {
2299                height: HeightProvider::Trapezoid {
2300                    min_inclusive: VerticalAnchor::Absolute(0i32),
2301                    max_inclusive: VerticalAnchor::Absolute(192i32),
2302                    plateau: 0i32,
2303                },
2304            },
2305            PlacementModifier::Biome,
2306        ],
2307    },
2308    id: OnceLock::new(),
2309});
2310pub static ORE_COAL_UPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2311    key: Identifier::vanilla_static("ore_coal_upper"),
2312    data: PlacedFeatureData {
2313        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_COAL),
2314        placement: vec![
2315            PlacementModifier::Count {
2316                count: IntProvider::Constant(30i32),
2317            },
2318            PlacementModifier::InSquare,
2319            PlacementModifier::HeightRange {
2320                height: HeightProvider::Uniform {
2321                    min_inclusive: VerticalAnchor::Absolute(136i32),
2322                    max_inclusive: VerticalAnchor::BelowTop(0i32),
2323                },
2324            },
2325            PlacementModifier::Biome,
2326        ],
2327    },
2328    id: OnceLock::new(),
2329});
2330pub static ORE_COPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2331    key: Identifier::vanilla_static("ore_copper"),
2332    data: PlacedFeatureData {
2333        feature: ConfiguredFeatureRef::Reference(
2334            &crate::vanilla_configured_features::ORE_COPPER_SMALL,
2335        ),
2336        placement: vec![
2337            PlacementModifier::Count {
2338                count: IntProvider::Constant(16i32),
2339            },
2340            PlacementModifier::InSquare,
2341            PlacementModifier::HeightRange {
2342                height: HeightProvider::Trapezoid {
2343                    min_inclusive: VerticalAnchor::Absolute(-16i32),
2344                    max_inclusive: VerticalAnchor::Absolute(112i32),
2345                    plateau: 0i32,
2346                },
2347            },
2348            PlacementModifier::Biome,
2349        ],
2350    },
2351    id: OnceLock::new(),
2352});
2353pub static ORE_COPPER_LARGE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2354    key: Identifier::vanilla_static("ore_copper_large"),
2355    data: PlacedFeatureData {
2356        feature: ConfiguredFeatureRef::Reference(
2357            &crate::vanilla_configured_features::ORE_COPPER_LARGE,
2358        ),
2359        placement: vec![
2360            PlacementModifier::Count {
2361                count: IntProvider::Constant(16i32),
2362            },
2363            PlacementModifier::InSquare,
2364            PlacementModifier::HeightRange {
2365                height: HeightProvider::Trapezoid {
2366                    min_inclusive: VerticalAnchor::Absolute(-16i32),
2367                    max_inclusive: VerticalAnchor::Absolute(112i32),
2368                    plateau: 0i32,
2369                },
2370            },
2371            PlacementModifier::Biome,
2372        ],
2373    },
2374    id: OnceLock::new(),
2375});
2376pub static ORE_DEBRIS_SMALL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2377    key: Identifier::vanilla_static("ore_debris_small"),
2378    data: PlacedFeatureData {
2379        feature: ConfiguredFeatureRef::Reference(
2380            &crate::vanilla_configured_features::ORE_ANCIENT_DEBRIS_SMALL,
2381        ),
2382        placement: vec![
2383            PlacementModifier::InSquare,
2384            PlacementModifier::HeightRange {
2385                height: HeightProvider::Uniform {
2386                    min_inclusive: VerticalAnchor::AboveBottom(8i32),
2387                    max_inclusive: VerticalAnchor::BelowTop(8i32),
2388                },
2389            },
2390            PlacementModifier::Biome,
2391        ],
2392    },
2393    id: OnceLock::new(),
2394});
2395pub static ORE_DIAMOND: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2396    key: Identifier::vanilla_static("ore_diamond"),
2397    data: PlacedFeatureData {
2398        feature: ConfiguredFeatureRef::Reference(
2399            &crate::vanilla_configured_features::ORE_DIAMOND_SMALL,
2400        ),
2401        placement: vec![
2402            PlacementModifier::Count {
2403                count: IntProvider::Constant(7i32),
2404            },
2405            PlacementModifier::InSquare,
2406            PlacementModifier::HeightRange {
2407                height: HeightProvider::Trapezoid {
2408                    min_inclusive: VerticalAnchor::AboveBottom(-80i32),
2409                    max_inclusive: VerticalAnchor::AboveBottom(80i32),
2410                    plateau: 0i32,
2411                },
2412            },
2413            PlacementModifier::Biome,
2414        ],
2415    },
2416    id: OnceLock::new(),
2417});
2418pub static ORE_DIAMOND_BURIED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2419    key: Identifier::vanilla_static("ore_diamond_buried"),
2420    data: PlacedFeatureData {
2421        feature: ConfiguredFeatureRef::Reference(
2422            &crate::vanilla_configured_features::ORE_DIAMOND_BURIED,
2423        ),
2424        placement: vec![
2425            PlacementModifier::Count {
2426                count: IntProvider::Constant(4i32),
2427            },
2428            PlacementModifier::InSquare,
2429            PlacementModifier::HeightRange {
2430                height: HeightProvider::Trapezoid {
2431                    min_inclusive: VerticalAnchor::AboveBottom(-80i32),
2432                    max_inclusive: VerticalAnchor::AboveBottom(80i32),
2433                    plateau: 0i32,
2434                },
2435            },
2436            PlacementModifier::Biome,
2437        ],
2438    },
2439    id: OnceLock::new(),
2440});
2441pub static ORE_DIAMOND_LARGE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2442    key: Identifier::vanilla_static("ore_diamond_large"),
2443    data: PlacedFeatureData {
2444        feature: ConfiguredFeatureRef::Reference(
2445            &crate::vanilla_configured_features::ORE_DIAMOND_LARGE,
2446        ),
2447        placement: vec![
2448            PlacementModifier::RarityFilter { chance: 9i32 },
2449            PlacementModifier::InSquare,
2450            PlacementModifier::HeightRange {
2451                height: HeightProvider::Trapezoid {
2452                    min_inclusive: VerticalAnchor::AboveBottom(-80i32),
2453                    max_inclusive: VerticalAnchor::AboveBottom(80i32),
2454                    plateau: 0i32,
2455                },
2456            },
2457            PlacementModifier::Biome,
2458        ],
2459    },
2460    id: OnceLock::new(),
2461});
2462pub static ORE_DIAMOND_MEDIUM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2463    key: Identifier::vanilla_static("ore_diamond_medium"),
2464    data: PlacedFeatureData {
2465        feature: ConfiguredFeatureRef::Reference(
2466            &crate::vanilla_configured_features::ORE_DIAMOND_MEDIUM,
2467        ),
2468        placement: vec![
2469            PlacementModifier::Count {
2470                count: IntProvider::Constant(2i32),
2471            },
2472            PlacementModifier::InSquare,
2473            PlacementModifier::HeightRange {
2474                height: HeightProvider::Uniform {
2475                    min_inclusive: VerticalAnchor::Absolute(-64i32),
2476                    max_inclusive: VerticalAnchor::Absolute(-4i32),
2477                },
2478            },
2479            PlacementModifier::Biome,
2480        ],
2481    },
2482    id: OnceLock::new(),
2483});
2484pub static ORE_DIORITE_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2485    key: Identifier::vanilla_static("ore_diorite_lower"),
2486    data: PlacedFeatureData {
2487        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_DIORITE),
2488        placement: vec![
2489            PlacementModifier::Count {
2490                count: IntProvider::Constant(2i32),
2491            },
2492            PlacementModifier::InSquare,
2493            PlacementModifier::HeightRange {
2494                height: HeightProvider::Uniform {
2495                    min_inclusive: VerticalAnchor::Absolute(0i32),
2496                    max_inclusive: VerticalAnchor::Absolute(60i32),
2497                },
2498            },
2499            PlacementModifier::Biome,
2500        ],
2501    },
2502    id: OnceLock::new(),
2503});
2504pub static ORE_DIORITE_UPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2505    key: Identifier::vanilla_static("ore_diorite_upper"),
2506    data: PlacedFeatureData {
2507        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_DIORITE),
2508        placement: vec![
2509            PlacementModifier::RarityFilter { chance: 6i32 },
2510            PlacementModifier::InSquare,
2511            PlacementModifier::HeightRange {
2512                height: HeightProvider::Uniform {
2513                    min_inclusive: VerticalAnchor::Absolute(64i32),
2514                    max_inclusive: VerticalAnchor::Absolute(128i32),
2515                },
2516            },
2517            PlacementModifier::Biome,
2518        ],
2519    },
2520    id: OnceLock::new(),
2521});
2522pub static ORE_DIRT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2523    key: Identifier::vanilla_static("ore_dirt"),
2524    data: PlacedFeatureData {
2525        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_DIRT),
2526        placement: vec![
2527            PlacementModifier::Count {
2528                count: IntProvider::Constant(7i32),
2529            },
2530            PlacementModifier::InSquare,
2531            PlacementModifier::HeightRange {
2532                height: HeightProvider::Uniform {
2533                    min_inclusive: VerticalAnchor::Absolute(0i32),
2534                    max_inclusive: VerticalAnchor::Absolute(160i32),
2535                },
2536            },
2537            PlacementModifier::Biome,
2538        ],
2539    },
2540    id: OnceLock::new(),
2541});
2542pub static ORE_EMERALD: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2543    key: Identifier::vanilla_static("ore_emerald"),
2544    data: PlacedFeatureData {
2545        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_EMERALD),
2546        placement: vec![
2547            PlacementModifier::Count {
2548                count: IntProvider::Constant(100i32),
2549            },
2550            PlacementModifier::InSquare,
2551            PlacementModifier::HeightRange {
2552                height: HeightProvider::Trapezoid {
2553                    min_inclusive: VerticalAnchor::Absolute(-16i32),
2554                    max_inclusive: VerticalAnchor::Absolute(480i32),
2555                    plateau: 0i32,
2556                },
2557            },
2558            PlacementModifier::Biome,
2559        ],
2560    },
2561    id: OnceLock::new(),
2562});
2563pub static ORE_GOLD: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2564    key: Identifier::vanilla_static("ore_gold"),
2565    data: PlacedFeatureData {
2566        feature: ConfiguredFeatureRef::Reference(
2567            &crate::vanilla_configured_features::ORE_GOLD_BURIED,
2568        ),
2569        placement: vec![
2570            PlacementModifier::Count {
2571                count: IntProvider::Constant(4i32),
2572            },
2573            PlacementModifier::InSquare,
2574            PlacementModifier::HeightRange {
2575                height: HeightProvider::Trapezoid {
2576                    min_inclusive: VerticalAnchor::Absolute(-64i32),
2577                    max_inclusive: VerticalAnchor::Absolute(32i32),
2578                    plateau: 0i32,
2579                },
2580            },
2581            PlacementModifier::Biome,
2582        ],
2583    },
2584    id: OnceLock::new(),
2585});
2586pub static ORE_GOLD_DELTAS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2587    key: Identifier::vanilla_static("ore_gold_deltas"),
2588    data: PlacedFeatureData {
2589        feature: ConfiguredFeatureRef::Reference(
2590            &crate::vanilla_configured_features::ORE_NETHER_GOLD,
2591        ),
2592        placement: vec![
2593            PlacementModifier::Count {
2594                count: IntProvider::Constant(20i32),
2595            },
2596            PlacementModifier::InSquare,
2597            PlacementModifier::HeightRange {
2598                height: HeightProvider::Uniform {
2599                    min_inclusive: VerticalAnchor::AboveBottom(10i32),
2600                    max_inclusive: VerticalAnchor::BelowTop(10i32),
2601                },
2602            },
2603            PlacementModifier::Biome,
2604        ],
2605    },
2606    id: OnceLock::new(),
2607});
2608pub static ORE_GOLD_EXTRA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2609    key: Identifier::vanilla_static("ore_gold_extra"),
2610    data: PlacedFeatureData {
2611        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_GOLD),
2612        placement: vec![
2613            PlacementModifier::Count {
2614                count: IntProvider::Constant(50i32),
2615            },
2616            PlacementModifier::InSquare,
2617            PlacementModifier::HeightRange {
2618                height: HeightProvider::Uniform {
2619                    min_inclusive: VerticalAnchor::Absolute(32i32),
2620                    max_inclusive: VerticalAnchor::Absolute(256i32),
2621                },
2622            },
2623            PlacementModifier::Biome,
2624        ],
2625    },
2626    id: OnceLock::new(),
2627});
2628pub static ORE_GOLD_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2629    key: Identifier::vanilla_static("ore_gold_lower"),
2630    data: PlacedFeatureData {
2631        feature: ConfiguredFeatureRef::Reference(
2632            &crate::vanilla_configured_features::ORE_GOLD_BURIED,
2633        ),
2634        placement: vec![
2635            PlacementModifier::Count {
2636                count: IntProvider::Uniform {
2637                    min_inclusive: 0i32,
2638                    max_inclusive: 1i32,
2639                },
2640            },
2641            PlacementModifier::InSquare,
2642            PlacementModifier::HeightRange {
2643                height: HeightProvider::Uniform {
2644                    min_inclusive: VerticalAnchor::Absolute(-64i32),
2645                    max_inclusive: VerticalAnchor::Absolute(-48i32),
2646                },
2647            },
2648            PlacementModifier::Biome,
2649        ],
2650    },
2651    id: OnceLock::new(),
2652});
2653pub static ORE_GOLD_NETHER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2654    key: Identifier::vanilla_static("ore_gold_nether"),
2655    data: PlacedFeatureData {
2656        feature: ConfiguredFeatureRef::Reference(
2657            &crate::vanilla_configured_features::ORE_NETHER_GOLD,
2658        ),
2659        placement: vec![
2660            PlacementModifier::Count {
2661                count: IntProvider::Constant(10i32),
2662            },
2663            PlacementModifier::InSquare,
2664            PlacementModifier::HeightRange {
2665                height: HeightProvider::Uniform {
2666                    min_inclusive: VerticalAnchor::AboveBottom(10i32),
2667                    max_inclusive: VerticalAnchor::BelowTop(10i32),
2668                },
2669            },
2670            PlacementModifier::Biome,
2671        ],
2672    },
2673    id: OnceLock::new(),
2674});
2675pub static ORE_GRANITE_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2676    key: Identifier::vanilla_static("ore_granite_lower"),
2677    data: PlacedFeatureData {
2678        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_GRANITE),
2679        placement: vec![
2680            PlacementModifier::Count {
2681                count: IntProvider::Constant(2i32),
2682            },
2683            PlacementModifier::InSquare,
2684            PlacementModifier::HeightRange {
2685                height: HeightProvider::Uniform {
2686                    min_inclusive: VerticalAnchor::Absolute(0i32),
2687                    max_inclusive: VerticalAnchor::Absolute(60i32),
2688                },
2689            },
2690            PlacementModifier::Biome,
2691        ],
2692    },
2693    id: OnceLock::new(),
2694});
2695pub static ORE_GRANITE_UPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2696    key: Identifier::vanilla_static("ore_granite_upper"),
2697    data: PlacedFeatureData {
2698        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_GRANITE),
2699        placement: vec![
2700            PlacementModifier::RarityFilter { chance: 6i32 },
2701            PlacementModifier::InSquare,
2702            PlacementModifier::HeightRange {
2703                height: HeightProvider::Uniform {
2704                    min_inclusive: VerticalAnchor::Absolute(64i32),
2705                    max_inclusive: VerticalAnchor::Absolute(128i32),
2706                },
2707            },
2708            PlacementModifier::Biome,
2709        ],
2710    },
2711    id: OnceLock::new(),
2712});
2713pub static ORE_GRAVEL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2714    key: Identifier::vanilla_static("ore_gravel"),
2715    data: PlacedFeatureData {
2716        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_GRAVEL),
2717        placement: vec![
2718            PlacementModifier::Count {
2719                count: IntProvider::Constant(14i32),
2720            },
2721            PlacementModifier::InSquare,
2722            PlacementModifier::HeightRange {
2723                height: HeightProvider::Uniform {
2724                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2725                    max_inclusive: VerticalAnchor::BelowTop(0i32),
2726                },
2727            },
2728            PlacementModifier::Biome,
2729        ],
2730    },
2731    id: OnceLock::new(),
2732});
2733pub static ORE_GRAVEL_NETHER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2734    key: Identifier::vanilla_static("ore_gravel_nether"),
2735    data: PlacedFeatureData {
2736        feature: ConfiguredFeatureRef::Reference(
2737            &crate::vanilla_configured_features::ORE_GRAVEL_NETHER,
2738        ),
2739        placement: vec![
2740            PlacementModifier::Count {
2741                count: IntProvider::Constant(2i32),
2742            },
2743            PlacementModifier::InSquare,
2744            PlacementModifier::HeightRange {
2745                height: HeightProvider::Uniform {
2746                    min_inclusive: VerticalAnchor::Absolute(5i32),
2747                    max_inclusive: VerticalAnchor::Absolute(41i32),
2748                },
2749            },
2750            PlacementModifier::Biome,
2751        ],
2752    },
2753    id: OnceLock::new(),
2754});
2755pub static ORE_INFESTED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2756    key: Identifier::vanilla_static("ore_infested"),
2757    data: PlacedFeatureData {
2758        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_INFESTED),
2759        placement: vec![
2760            PlacementModifier::Count {
2761                count: IntProvider::Constant(14i32),
2762            },
2763            PlacementModifier::InSquare,
2764            PlacementModifier::HeightRange {
2765                height: HeightProvider::Uniform {
2766                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2767                    max_inclusive: VerticalAnchor::Absolute(63i32),
2768                },
2769            },
2770            PlacementModifier::Biome,
2771        ],
2772    },
2773    id: OnceLock::new(),
2774});
2775pub static ORE_IRON_MIDDLE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2776    key: Identifier::vanilla_static("ore_iron_middle"),
2777    data: PlacedFeatureData {
2778        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_IRON),
2779        placement: vec![
2780            PlacementModifier::Count {
2781                count: IntProvider::Constant(10i32),
2782            },
2783            PlacementModifier::InSquare,
2784            PlacementModifier::HeightRange {
2785                height: HeightProvider::Trapezoid {
2786                    min_inclusive: VerticalAnchor::Absolute(-24i32),
2787                    max_inclusive: VerticalAnchor::Absolute(56i32),
2788                    plateau: 0i32,
2789                },
2790            },
2791            PlacementModifier::Biome,
2792        ],
2793    },
2794    id: OnceLock::new(),
2795});
2796pub static ORE_IRON_SMALL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2797    key: Identifier::vanilla_static("ore_iron_small"),
2798    data: PlacedFeatureData {
2799        feature: ConfiguredFeatureRef::Reference(
2800            &crate::vanilla_configured_features::ORE_IRON_SMALL,
2801        ),
2802        placement: vec![
2803            PlacementModifier::Count {
2804                count: IntProvider::Constant(10i32),
2805            },
2806            PlacementModifier::InSquare,
2807            PlacementModifier::HeightRange {
2808                height: HeightProvider::Uniform {
2809                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2810                    max_inclusive: VerticalAnchor::Absolute(72i32),
2811                },
2812            },
2813            PlacementModifier::Biome,
2814        ],
2815    },
2816    id: OnceLock::new(),
2817});
2818pub static ORE_IRON_UPPER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2819    key: Identifier::vanilla_static("ore_iron_upper"),
2820    data: PlacedFeatureData {
2821        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_IRON),
2822        placement: vec![
2823            PlacementModifier::Count {
2824                count: IntProvider::Constant(90i32),
2825            },
2826            PlacementModifier::InSquare,
2827            PlacementModifier::HeightRange {
2828                height: HeightProvider::Trapezoid {
2829                    min_inclusive: VerticalAnchor::Absolute(80i32),
2830                    max_inclusive: VerticalAnchor::Absolute(384i32),
2831                    plateau: 0i32,
2832                },
2833            },
2834            PlacementModifier::Biome,
2835        ],
2836    },
2837    id: OnceLock::new(),
2838});
2839pub static ORE_LAPIS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2840    key: Identifier::vanilla_static("ore_lapis"),
2841    data: PlacedFeatureData {
2842        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_LAPIS),
2843        placement: vec![
2844            PlacementModifier::Count {
2845                count: IntProvider::Constant(2i32),
2846            },
2847            PlacementModifier::InSquare,
2848            PlacementModifier::HeightRange {
2849                height: HeightProvider::Trapezoid {
2850                    min_inclusive: VerticalAnchor::Absolute(-32i32),
2851                    max_inclusive: VerticalAnchor::Absolute(32i32),
2852                    plateau: 0i32,
2853                },
2854            },
2855            PlacementModifier::Biome,
2856        ],
2857    },
2858    id: OnceLock::new(),
2859});
2860pub static ORE_LAPIS_BURIED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2861    key: Identifier::vanilla_static("ore_lapis_buried"),
2862    data: PlacedFeatureData {
2863        feature: ConfiguredFeatureRef::Reference(
2864            &crate::vanilla_configured_features::ORE_LAPIS_BURIED,
2865        ),
2866        placement: vec![
2867            PlacementModifier::Count {
2868                count: IntProvider::Constant(4i32),
2869            },
2870            PlacementModifier::InSquare,
2871            PlacementModifier::HeightRange {
2872                height: HeightProvider::Uniform {
2873                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2874                    max_inclusive: VerticalAnchor::Absolute(64i32),
2875                },
2876            },
2877            PlacementModifier::Biome,
2878        ],
2879    },
2880    id: OnceLock::new(),
2881});
2882pub static ORE_MAGMA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2883    key: Identifier::vanilla_static("ore_magma"),
2884    data: PlacedFeatureData {
2885        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_MAGMA),
2886        placement: vec![
2887            PlacementModifier::Count {
2888                count: IntProvider::Constant(4i32),
2889            },
2890            PlacementModifier::InSquare,
2891            PlacementModifier::HeightRange {
2892                height: HeightProvider::Uniform {
2893                    min_inclusive: VerticalAnchor::Absolute(27i32),
2894                    max_inclusive: VerticalAnchor::Absolute(36i32),
2895                },
2896            },
2897            PlacementModifier::Biome,
2898        ],
2899    },
2900    id: OnceLock::new(),
2901});
2902pub static ORE_QUARTZ_DELTAS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2903    key: Identifier::vanilla_static("ore_quartz_deltas"),
2904    data: PlacedFeatureData {
2905        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_QUARTZ),
2906        placement: vec![
2907            PlacementModifier::Count {
2908                count: IntProvider::Constant(32i32),
2909            },
2910            PlacementModifier::InSquare,
2911            PlacementModifier::HeightRange {
2912                height: HeightProvider::Uniform {
2913                    min_inclusive: VerticalAnchor::AboveBottom(10i32),
2914                    max_inclusive: VerticalAnchor::BelowTop(10i32),
2915                },
2916            },
2917            PlacementModifier::Biome,
2918        ],
2919    },
2920    id: OnceLock::new(),
2921});
2922pub static ORE_QUARTZ_NETHER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2923    key: Identifier::vanilla_static("ore_quartz_nether"),
2924    data: PlacedFeatureData {
2925        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_QUARTZ),
2926        placement: vec![
2927            PlacementModifier::Count {
2928                count: IntProvider::Constant(16i32),
2929            },
2930            PlacementModifier::InSquare,
2931            PlacementModifier::HeightRange {
2932                height: HeightProvider::Uniform {
2933                    min_inclusive: VerticalAnchor::AboveBottom(10i32),
2934                    max_inclusive: VerticalAnchor::BelowTop(10i32),
2935                },
2936            },
2937            PlacementModifier::Biome,
2938        ],
2939    },
2940    id: OnceLock::new(),
2941});
2942pub static ORE_REDSTONE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2943    key: Identifier::vanilla_static("ore_redstone"),
2944    data: PlacedFeatureData {
2945        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_REDSTONE),
2946        placement: vec![
2947            PlacementModifier::Count {
2948                count: IntProvider::Constant(4i32),
2949            },
2950            PlacementModifier::InSquare,
2951            PlacementModifier::HeightRange {
2952                height: HeightProvider::Uniform {
2953                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2954                    max_inclusive: VerticalAnchor::Absolute(15i32),
2955                },
2956            },
2957            PlacementModifier::Biome,
2958        ],
2959    },
2960    id: OnceLock::new(),
2961});
2962pub static ORE_REDSTONE_LOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2963    key: Identifier::vanilla_static("ore_redstone_lower"),
2964    data: PlacedFeatureData {
2965        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_REDSTONE),
2966        placement: vec![
2967            PlacementModifier::Count {
2968                count: IntProvider::Constant(8i32),
2969            },
2970            PlacementModifier::InSquare,
2971            PlacementModifier::HeightRange {
2972                height: HeightProvider::Trapezoid {
2973                    min_inclusive: VerticalAnchor::AboveBottom(-32i32),
2974                    max_inclusive: VerticalAnchor::AboveBottom(32i32),
2975                    plateau: 0i32,
2976                },
2977            },
2978            PlacementModifier::Biome,
2979        ],
2980    },
2981    id: OnceLock::new(),
2982});
2983pub static ORE_SOUL_SAND: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
2984    key: Identifier::vanilla_static("ore_soul_sand"),
2985    data: PlacedFeatureData {
2986        feature: ConfiguredFeatureRef::Reference(
2987            &crate::vanilla_configured_features::ORE_SOUL_SAND,
2988        ),
2989        placement: vec![
2990            PlacementModifier::Count {
2991                count: IntProvider::Constant(12i32),
2992            },
2993            PlacementModifier::InSquare,
2994            PlacementModifier::HeightRange {
2995                height: HeightProvider::Uniform {
2996                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
2997                    max_inclusive: VerticalAnchor::Absolute(31i32),
2998                },
2999            },
3000            PlacementModifier::Biome,
3001        ],
3002    },
3003    id: OnceLock::new(),
3004});
3005pub static ORE_TUFF: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3006    key: Identifier::vanilla_static("ore_tuff"),
3007    data: PlacedFeatureData {
3008        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::ORE_TUFF),
3009        placement: vec![
3010            PlacementModifier::Count {
3011                count: IntProvider::Constant(2i32),
3012            },
3013            PlacementModifier::InSquare,
3014            PlacementModifier::HeightRange {
3015                height: HeightProvider::Uniform {
3016                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
3017                    max_inclusive: VerticalAnchor::Absolute(0i32),
3018                },
3019            },
3020            PlacementModifier::Biome,
3021        ],
3022    },
3023    id: OnceLock::new(),
3024});
3025pub static PALE_GARDEN_FLOWERS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3026    key: Identifier::vanilla_static("pale_garden_flowers"),
3027    data: PlacedFeatureData {
3028        feature: ConfiguredFeatureRef::Reference(
3029            &crate::vanilla_configured_features::PALE_FOREST_FLOWER,
3030        ),
3031        placement: vec![
3032            PlacementModifier::RarityFilter { chance: 8i32 },
3033            PlacementModifier::InSquare,
3034            PlacementModifier::Heightmap {
3035                heightmap: FeatureHeightmap::MotionBlockingNoLeaves,
3036            },
3037            PlacementModifier::Biome,
3038            PlacementModifier::Count {
3039                count: IntProvider::Constant(96i32),
3040            },
3041            PlacementModifier::RandomOffset {
3042                xz_spread: IntProvider::Trapezoid {
3043                    min: -7i32,
3044                    max: 7i32,
3045                    plateau: 0i32,
3046                },
3047                y_spread: IntProvider::Trapezoid {
3048                    min: -3i32,
3049                    max: 3i32,
3050                    plateau: 0i32,
3051                },
3052            },
3053            PlacementModifier::BlockPredicateFilter {
3054                predicate: BlockPredicate::MatchingBlockTag {
3055                    tag: Identifier::vanilla_static("air"),
3056                    offset: [0i32, 0i32, 0i32],
3057                },
3058            },
3059        ],
3060    },
3061    id: OnceLock::new(),
3062});
3063pub static PALE_GARDEN_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3064    key: Identifier::vanilla_static("pale_garden_vegetation"),
3065    data: PlacedFeatureData {
3066        feature: ConfiguredFeatureRef::Reference(
3067            &crate::vanilla_configured_features::PALE_GARDEN_VEGETATION,
3068        ),
3069        placement: vec![
3070            PlacementModifier::Count {
3071                count: IntProvider::Constant(16i32),
3072            },
3073            PlacementModifier::InSquare,
3074            PlacementModifier::SurfaceWaterDepthFilter {
3075                max_water_depth: 0i32,
3076            },
3077            PlacementModifier::Heightmap {
3078                heightmap: FeatureHeightmap::OceanFloor,
3079            },
3080            PlacementModifier::Biome,
3081        ],
3082    },
3083    id: OnceLock::new(),
3084});
3085pub static PALE_MOSS_PATCH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3086    key: Identifier::vanilla_static("pale_moss_patch"),
3087    data: PlacedFeatureData {
3088        feature: ConfiguredFeatureRef::Reference(
3089            &crate::vanilla_configured_features::PALE_MOSS_PATCH,
3090        ),
3091        placement: vec![
3092            PlacementModifier::Count {
3093                count: IntProvider::Constant(1i32),
3094            },
3095            PlacementModifier::InSquare,
3096            PlacementModifier::Heightmap {
3097                heightmap: FeatureHeightmap::MotionBlockingNoLeaves,
3098            },
3099            PlacementModifier::Biome,
3100        ],
3101    },
3102    id: OnceLock::new(),
3103});
3104pub static PALE_OAK_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3105    key: Identifier::vanilla_static("pale_oak_checked"),
3106    data: PlacedFeatureData {
3107        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PALE_OAK),
3108        placement: vec![PlacementModifier::BlockPredicateFilter {
3109            predicate: BlockPredicate::WouldSurvive {
3110                state: BlockStateData {
3111                    block: &vanilla_blocks::PALE_OAK_SAPLING,
3112                    properties: &[("stage", "0")],
3113                },
3114                offset: [0i32, 0i32, 0i32],
3115            },
3116        }],
3117    },
3118    id: OnceLock::new(),
3119});
3120pub static PALE_OAK_CREAKING_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3121    key: Identifier::vanilla_static("pale_oak_creaking_checked"),
3122    data: PlacedFeatureData {
3123        feature: ConfiguredFeatureRef::Reference(
3124            &crate::vanilla_configured_features::PALE_OAK_CREAKING,
3125        ),
3126        placement: vec![PlacementModifier::BlockPredicateFilter {
3127            predicate: BlockPredicate::WouldSurvive {
3128                state: BlockStateData {
3129                    block: &vanilla_blocks::PALE_OAK_SAPLING,
3130                    properties: &[("stage", "0")],
3131                },
3132                offset: [0i32, 0i32, 0i32],
3133            },
3134        }],
3135    },
3136    id: OnceLock::new(),
3137});
3138pub static PATCH_BERRY_BUSH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3139    key: Identifier::vanilla_static("patch_berry_bush"),
3140    data: PlacedFeatureData {
3141        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BERRY_BUSH),
3142        placement: vec![
3143            PlacementModifier::Count {
3144                count: IntProvider::Constant(96i32),
3145            },
3146            PlacementModifier::RandomOffset {
3147                xz_spread: IntProvider::Trapezoid {
3148                    min: -7i32,
3149                    max: 7i32,
3150                    plateau: 0i32,
3151                },
3152                y_spread: IntProvider::Trapezoid {
3153                    min: -3i32,
3154                    max: 3i32,
3155                    plateau: 0i32,
3156                },
3157            },
3158            PlacementModifier::BlockPredicateFilter {
3159                predicate: BlockPredicate::AllOf {
3160                    predicates: vec![
3161                        BlockPredicate::MatchingBlockTag {
3162                            tag: Identifier::vanilla_static("air"),
3163                            offset: [0i32, 0i32, 0i32],
3164                        },
3165                        BlockPredicate::MatchingBlocks {
3166                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
3167                            offset: [0i32, -1i32, 0i32],
3168                        },
3169                    ],
3170                },
3171            },
3172        ],
3173    },
3174    id: OnceLock::new(),
3175});
3176pub static PATCH_BERRY_COMMON: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3177    key: Identifier::vanilla_static("patch_berry_common"),
3178    data: PlacedFeatureData {
3179        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BERRY_BUSH),
3180        placement: vec![
3181            PlacementModifier::RarityFilter { chance: 32i32 },
3182            PlacementModifier::InSquare,
3183            PlacementModifier::Heightmap {
3184                heightmap: FeatureHeightmap::WorldSurfaceWg,
3185            },
3186            PlacementModifier::Biome,
3187            PlacementModifier::Count {
3188                count: IntProvider::Constant(96i32),
3189            },
3190            PlacementModifier::RandomOffset {
3191                xz_spread: IntProvider::Trapezoid {
3192                    min: -7i32,
3193                    max: 7i32,
3194                    plateau: 0i32,
3195                },
3196                y_spread: IntProvider::Trapezoid {
3197                    min: -3i32,
3198                    max: 3i32,
3199                    plateau: 0i32,
3200                },
3201            },
3202            PlacementModifier::BlockPredicateFilter {
3203                predicate: BlockPredicate::AllOf {
3204                    predicates: vec![
3205                        BlockPredicate::MatchingBlockTag {
3206                            tag: Identifier::vanilla_static("air"),
3207                            offset: [0i32, 0i32, 0i32],
3208                        },
3209                        BlockPredicate::MatchingBlocks {
3210                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
3211                            offset: [0i32, -1i32, 0i32],
3212                        },
3213                    ],
3214                },
3215            },
3216        ],
3217    },
3218    id: OnceLock::new(),
3219});
3220pub static PATCH_BERRY_RARE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3221    key: Identifier::vanilla_static("patch_berry_rare"),
3222    data: PlacedFeatureData {
3223        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BERRY_BUSH),
3224        placement: vec![
3225            PlacementModifier::RarityFilter { chance: 384i32 },
3226            PlacementModifier::InSquare,
3227            PlacementModifier::Heightmap {
3228                heightmap: FeatureHeightmap::WorldSurfaceWg,
3229            },
3230            PlacementModifier::Biome,
3231            PlacementModifier::Count {
3232                count: IntProvider::Constant(96i32),
3233            },
3234            PlacementModifier::RandomOffset {
3235                xz_spread: IntProvider::Trapezoid {
3236                    min: -7i32,
3237                    max: 7i32,
3238                    plateau: 0i32,
3239                },
3240                y_spread: IntProvider::Trapezoid {
3241                    min: -3i32,
3242                    max: 3i32,
3243                    plateau: 0i32,
3244                },
3245            },
3246            PlacementModifier::BlockPredicateFilter {
3247                predicate: BlockPredicate::AllOf {
3248                    predicates: vec![
3249                        BlockPredicate::MatchingBlockTag {
3250                            tag: Identifier::vanilla_static("air"),
3251                            offset: [0i32, 0i32, 0i32],
3252                        },
3253                        BlockPredicate::MatchingBlocks {
3254                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
3255                            offset: [0i32, -1i32, 0i32],
3256                        },
3257                    ],
3258                },
3259            },
3260        ],
3261    },
3262    id: OnceLock::new(),
3263});
3264pub static PATCH_BUSH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3265    key: Identifier::vanilla_static("patch_bush"),
3266    data: PlacedFeatureData {
3267        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::BUSH),
3268        placement: vec![
3269            PlacementModifier::RarityFilter { chance: 4i32 },
3270            PlacementModifier::InSquare,
3271            PlacementModifier::Heightmap {
3272                heightmap: FeatureHeightmap::MotionBlocking,
3273            },
3274            PlacementModifier::Biome,
3275            PlacementModifier::Count {
3276                count: IntProvider::Constant(24i32),
3277            },
3278            PlacementModifier::RandomOffset {
3279                xz_spread: IntProvider::Trapezoid {
3280                    min: -5i32,
3281                    max: 5i32,
3282                    plateau: 0i32,
3283                },
3284                y_spread: IntProvider::Trapezoid {
3285                    min: -3i32,
3286                    max: 3i32,
3287                    plateau: 0i32,
3288                },
3289            },
3290            PlacementModifier::BlockPredicateFilter {
3291                predicate: BlockPredicate::MatchingBlockTag {
3292                    tag: Identifier::vanilla_static("air"),
3293                    offset: [0i32, 0i32, 0i32],
3294                },
3295            },
3296        ],
3297    },
3298    id: OnceLock::new(),
3299});
3300pub static PATCH_CACTUS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3301    key: Identifier::vanilla_static("patch_cactus"),
3302    data: PlacedFeatureData {
3303        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::CACTUS),
3304        placement: vec![
3305            PlacementModifier::Count {
3306                count: IntProvider::Constant(10i32),
3307            },
3308            PlacementModifier::RandomOffset {
3309                xz_spread: IntProvider::Trapezoid {
3310                    min: -7i32,
3311                    max: 7i32,
3312                    plateau: 0i32,
3313                },
3314                y_spread: IntProvider::Trapezoid {
3315                    min: -3i32,
3316                    max: 3i32,
3317                    plateau: 0i32,
3318                },
3319            },
3320            PlacementModifier::BlockPredicateFilter {
3321                predicate: BlockPredicate::AllOf {
3322                    predicates: vec![
3323                        BlockPredicate::MatchingBlockTag {
3324                            tag: Identifier::vanilla_static("air"),
3325                            offset: [0i32, 0i32, 0i32],
3326                        },
3327                        BlockPredicate::WouldSurvive {
3328                            state: BlockStateData {
3329                                block: &vanilla_blocks::CACTUS,
3330                                properties: &[("age", "0")],
3331                            },
3332                            offset: [0i32, 0i32, 0i32],
3333                        },
3334                    ],
3335                },
3336            },
3337        ],
3338    },
3339    id: OnceLock::new(),
3340});
3341pub static PATCH_CACTUS_DECORATED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3342    key: Identifier::vanilla_static("patch_cactus_decorated"),
3343    data: PlacedFeatureData {
3344        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::CACTUS),
3345        placement: vec![
3346            PlacementModifier::RarityFilter { chance: 13i32 },
3347            PlacementModifier::InSquare,
3348            PlacementModifier::Heightmap {
3349                heightmap: FeatureHeightmap::MotionBlocking,
3350            },
3351            PlacementModifier::Biome,
3352            PlacementModifier::Count {
3353                count: IntProvider::Constant(10i32),
3354            },
3355            PlacementModifier::RandomOffset {
3356                xz_spread: IntProvider::Trapezoid {
3357                    min: -7i32,
3358                    max: 7i32,
3359                    plateau: 0i32,
3360                },
3361                y_spread: IntProvider::Trapezoid {
3362                    min: -3i32,
3363                    max: 3i32,
3364                    plateau: 0i32,
3365                },
3366            },
3367            PlacementModifier::BlockPredicateFilter {
3368                predicate: BlockPredicate::AllOf {
3369                    predicates: vec![
3370                        BlockPredicate::MatchingBlockTag {
3371                            tag: Identifier::vanilla_static("air"),
3372                            offset: [0i32, 0i32, 0i32],
3373                        },
3374                        BlockPredicate::WouldSurvive {
3375                            state: BlockStateData {
3376                                block: &vanilla_blocks::CACTUS,
3377                                properties: &[("age", "0")],
3378                            },
3379                            offset: [0i32, 0i32, 0i32],
3380                        },
3381                    ],
3382                },
3383            },
3384        ],
3385    },
3386    id: OnceLock::new(),
3387});
3388pub static PATCH_CACTUS_DESERT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3389    key: Identifier::vanilla_static("patch_cactus_desert"),
3390    data: PlacedFeatureData {
3391        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::CACTUS),
3392        placement: vec![
3393            PlacementModifier::RarityFilter { chance: 6i32 },
3394            PlacementModifier::InSquare,
3395            PlacementModifier::Heightmap {
3396                heightmap: FeatureHeightmap::MotionBlocking,
3397            },
3398            PlacementModifier::Biome,
3399            PlacementModifier::Count {
3400                count: IntProvider::Constant(10i32),
3401            },
3402            PlacementModifier::RandomOffset {
3403                xz_spread: IntProvider::Trapezoid {
3404                    min: -7i32,
3405                    max: 7i32,
3406                    plateau: 0i32,
3407                },
3408                y_spread: IntProvider::Trapezoid {
3409                    min: -3i32,
3410                    max: 3i32,
3411                    plateau: 0i32,
3412                },
3413            },
3414            PlacementModifier::BlockPredicateFilter {
3415                predicate: BlockPredicate::AllOf {
3416                    predicates: vec![
3417                        BlockPredicate::MatchingBlockTag {
3418                            tag: Identifier::vanilla_static("air"),
3419                            offset: [0i32, 0i32, 0i32],
3420                        },
3421                        BlockPredicate::WouldSurvive {
3422                            state: BlockStateData {
3423                                block: &vanilla_blocks::CACTUS,
3424                                properties: &[("age", "0")],
3425                            },
3426                            offset: [0i32, 0i32, 0i32],
3427                        },
3428                    ],
3429                },
3430            },
3431        ],
3432    },
3433    id: OnceLock::new(),
3434});
3435pub static PATCH_CRIMSON_ROOTS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3436    key: Identifier::vanilla_static("patch_crimson_roots"),
3437    data: PlacedFeatureData {
3438        feature: ConfiguredFeatureRef::Reference(
3439            &crate::vanilla_configured_features::CRIMSON_ROOTS,
3440        ),
3441        placement: vec![
3442            PlacementModifier::HeightRange {
3443                height: HeightProvider::Uniform {
3444                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
3445                    max_inclusive: VerticalAnchor::BelowTop(0i32),
3446                },
3447            },
3448            PlacementModifier::Biome,
3449            PlacementModifier::Count {
3450                count: IntProvider::Constant(96i32),
3451            },
3452            PlacementModifier::RandomOffset {
3453                xz_spread: IntProvider::Trapezoid {
3454                    min: -7i32,
3455                    max: 7i32,
3456                    plateau: 0i32,
3457                },
3458                y_spread: IntProvider::Trapezoid {
3459                    min: -3i32,
3460                    max: 3i32,
3461                    plateau: 0i32,
3462                },
3463            },
3464            PlacementModifier::BlockPredicateFilter {
3465                predicate: BlockPredicate::MatchingBlockTag {
3466                    tag: Identifier::vanilla_static("air"),
3467                    offset: [0i32, 0i32, 0i32],
3468                },
3469            },
3470        ],
3471    },
3472    id: OnceLock::new(),
3473});
3474pub static PATCH_DEAD_BUSH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3475    key: Identifier::vanilla_static("patch_dead_bush"),
3476    data: PlacedFeatureData {
3477        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DEAD_BUSH),
3478        placement: vec![
3479            PlacementModifier::InSquare,
3480            PlacementModifier::Heightmap {
3481                heightmap: FeatureHeightmap::WorldSurfaceWg,
3482            },
3483            PlacementModifier::Biome,
3484            PlacementModifier::Count {
3485                count: IntProvider::Constant(4i32),
3486            },
3487            PlacementModifier::RandomOffset {
3488                xz_spread: IntProvider::Trapezoid {
3489                    min: -7i32,
3490                    max: 7i32,
3491                    plateau: 0i32,
3492                },
3493                y_spread: IntProvider::Trapezoid {
3494                    min: -3i32,
3495                    max: 3i32,
3496                    plateau: 0i32,
3497                },
3498            },
3499            PlacementModifier::BlockPredicateFilter {
3500                predicate: BlockPredicate::MatchingBlockTag {
3501                    tag: Identifier::vanilla_static("air"),
3502                    offset: [0i32, 0i32, 0i32],
3503                },
3504            },
3505        ],
3506    },
3507    id: OnceLock::new(),
3508});
3509pub static PATCH_DEAD_BUSH_2: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3510    key: Identifier::vanilla_static("patch_dead_bush_2"),
3511    data: PlacedFeatureData {
3512        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DEAD_BUSH),
3513        placement: vec![
3514            PlacementModifier::Count {
3515                count: IntProvider::Constant(2i32),
3516            },
3517            PlacementModifier::InSquare,
3518            PlacementModifier::Heightmap {
3519                heightmap: FeatureHeightmap::WorldSurfaceWg,
3520            },
3521            PlacementModifier::Biome,
3522            PlacementModifier::Count {
3523                count: IntProvider::Constant(4i32),
3524            },
3525            PlacementModifier::RandomOffset {
3526                xz_spread: IntProvider::Trapezoid {
3527                    min: -7i32,
3528                    max: 7i32,
3529                    plateau: 0i32,
3530                },
3531                y_spread: IntProvider::Trapezoid {
3532                    min: -3i32,
3533                    max: 3i32,
3534                    plateau: 0i32,
3535                },
3536            },
3537            PlacementModifier::BlockPredicateFilter {
3538                predicate: BlockPredicate::MatchingBlockTag {
3539                    tag: Identifier::vanilla_static("air"),
3540                    offset: [0i32, 0i32, 0i32],
3541                },
3542            },
3543        ],
3544    },
3545    id: OnceLock::new(),
3546});
3547pub static PATCH_DEAD_BUSH_BADLANDS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3548    key: Identifier::vanilla_static("patch_dead_bush_badlands"),
3549    data: PlacedFeatureData {
3550        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DEAD_BUSH),
3551        placement: vec![
3552            PlacementModifier::Count {
3553                count: IntProvider::Constant(20i32),
3554            },
3555            PlacementModifier::InSquare,
3556            PlacementModifier::Heightmap {
3557                heightmap: FeatureHeightmap::WorldSurfaceWg,
3558            },
3559            PlacementModifier::Biome,
3560            PlacementModifier::Count {
3561                count: IntProvider::Constant(4i32),
3562            },
3563            PlacementModifier::RandomOffset {
3564                xz_spread: IntProvider::Trapezoid {
3565                    min: -7i32,
3566                    max: 7i32,
3567                    plateau: 0i32,
3568                },
3569                y_spread: IntProvider::Trapezoid {
3570                    min: -3i32,
3571                    max: 3i32,
3572                    plateau: 0i32,
3573                },
3574            },
3575            PlacementModifier::BlockPredicateFilter {
3576                predicate: BlockPredicate::MatchingBlockTag {
3577                    tag: Identifier::vanilla_static("air"),
3578                    offset: [0i32, 0i32, 0i32],
3579                },
3580            },
3581        ],
3582    },
3583    id: OnceLock::new(),
3584});
3585pub static PATCH_DRY_GRASS_BADLANDS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3586    key: Identifier::vanilla_static("patch_dry_grass_badlands"),
3587    data: PlacedFeatureData {
3588        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DRY_GRASS),
3589        placement: vec![
3590            PlacementModifier::RarityFilter { chance: 6i32 },
3591            PlacementModifier::InSquare,
3592            PlacementModifier::Heightmap {
3593                heightmap: FeatureHeightmap::MotionBlocking,
3594            },
3595            PlacementModifier::Biome,
3596            PlacementModifier::Count {
3597                count: IntProvider::Constant(64i32),
3598            },
3599            PlacementModifier::RandomOffset {
3600                xz_spread: IntProvider::Trapezoid {
3601                    min: -7i32,
3602                    max: 7i32,
3603                    plateau: 0i32,
3604                },
3605                y_spread: IntProvider::Trapezoid {
3606                    min: -3i32,
3607                    max: 3i32,
3608                    plateau: 0i32,
3609                },
3610            },
3611            PlacementModifier::BlockPredicateFilter {
3612                predicate: BlockPredicate::MatchingBlockTag {
3613                    tag: Identifier::vanilla_static("air"),
3614                    offset: [0i32, 0i32, 0i32],
3615                },
3616            },
3617        ],
3618    },
3619    id: OnceLock::new(),
3620});
3621pub static PATCH_DRY_GRASS_DESERT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3622    key: Identifier::vanilla_static("patch_dry_grass_desert"),
3623    data: PlacedFeatureData {
3624        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::DRY_GRASS),
3625        placement: vec![
3626            PlacementModifier::RarityFilter { chance: 3i32 },
3627            PlacementModifier::InSquare,
3628            PlacementModifier::Heightmap {
3629                heightmap: FeatureHeightmap::MotionBlocking,
3630            },
3631            PlacementModifier::Biome,
3632            PlacementModifier::Count {
3633                count: IntProvider::Constant(64i32),
3634            },
3635            PlacementModifier::RandomOffset {
3636                xz_spread: IntProvider::Trapezoid {
3637                    min: -7i32,
3638                    max: 7i32,
3639                    plateau: 0i32,
3640                },
3641                y_spread: IntProvider::Trapezoid {
3642                    min: -3i32,
3643                    max: 3i32,
3644                    plateau: 0i32,
3645                },
3646            },
3647            PlacementModifier::BlockPredicateFilter {
3648                predicate: BlockPredicate::MatchingBlockTag {
3649                    tag: Identifier::vanilla_static("air"),
3650                    offset: [0i32, 0i32, 0i32],
3651                },
3652            },
3653        ],
3654    },
3655    id: OnceLock::new(),
3656});
3657pub static PATCH_FIRE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3658    key: Identifier::vanilla_static("patch_fire"),
3659    data: PlacedFeatureData {
3660        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PATCH_FIRE),
3661        placement: vec![
3662            PlacementModifier::Count {
3663                count: IntProvider::Uniform {
3664                    min_inclusive: 0i32,
3665                    max_inclusive: 5i32,
3666                },
3667            },
3668            PlacementModifier::InSquare,
3669            PlacementModifier::HeightRange {
3670                height: HeightProvider::Uniform {
3671                    min_inclusive: VerticalAnchor::AboveBottom(4i32),
3672                    max_inclusive: VerticalAnchor::BelowTop(4i32),
3673                },
3674            },
3675            PlacementModifier::Biome,
3676            PlacementModifier::Count {
3677                count: IntProvider::Constant(96i32),
3678            },
3679            PlacementModifier::RandomOffset {
3680                xz_spread: IntProvider::Trapezoid {
3681                    min: -7i32,
3682                    max: 7i32,
3683                    plateau: 0i32,
3684                },
3685                y_spread: IntProvider::Trapezoid {
3686                    min: -3i32,
3687                    max: 3i32,
3688                    plateau: 0i32,
3689                },
3690            },
3691            PlacementModifier::BlockPredicateFilter {
3692                predicate: BlockPredicate::AllOf {
3693                    predicates: vec![
3694                        BlockPredicate::MatchingBlockTag {
3695                            tag: Identifier::vanilla_static("air"),
3696                            offset: [0i32, 0i32, 0i32],
3697                        },
3698                        BlockPredicate::MatchingBlocks {
3699                            blocks: BlockRefList(vec![&vanilla_blocks::NETHERRACK]),
3700                            offset: [0i32, -1i32, 0i32],
3701                        },
3702                    ],
3703                },
3704            },
3705        ],
3706    },
3707    id: OnceLock::new(),
3708});
3709pub static PATCH_FIREFLY_BUSH_NEAR_WATER: LazyLock<PlacedFeature> =
3710    LazyLock::new(|| PlacedFeature {
3711        key: Identifier::vanilla_static("patch_firefly_bush_near_water"),
3712        data: PlacedFeatureData {
3713            feature: ConfiguredFeatureRef::Reference(
3714                &crate::vanilla_configured_features::FIREFLY_BUSH,
3715            ),
3716            placement: vec![
3717                PlacementModifier::Count {
3718                    count: IntProvider::Constant(2i32),
3719                },
3720                PlacementModifier::InSquare,
3721                PlacementModifier::Heightmap {
3722                    heightmap: FeatureHeightmap::MotionBlockingNoLeaves,
3723                },
3724                PlacementModifier::Biome,
3725                PlacementModifier::BlockPredicateFilter {
3726                    predicate: BlockPredicate::AllOf {
3727                        predicates: vec![
3728                            BlockPredicate::MatchingBlockTag {
3729                                tag: Identifier::vanilla_static("air"),
3730                                offset: [0i32, 0i32, 0i32],
3731                            },
3732                            BlockPredicate::WouldSurvive {
3733                                state: BlockStateData {
3734                                    block: &vanilla_blocks::FIREFLY_BUSH,
3735                                    properties: &[],
3736                                },
3737                                offset: [0i32, 0i32, 0i32],
3738                            },
3739                            BlockPredicate::AnyOf {
3740                                predicates: vec![
3741                                    BlockPredicate::MatchingFluids {
3742                                        fluids: FluidRefList(vec![
3743                                            &vanilla_fluids::WATER,
3744                                            &vanilla_fluids::FLOWING_WATER,
3745                                        ]),
3746                                        offset: [1i32, -1i32, 0i32],
3747                                    },
3748                                    BlockPredicate::MatchingFluids {
3749                                        fluids: FluidRefList(vec![
3750                                            &vanilla_fluids::WATER,
3751                                            &vanilla_fluids::FLOWING_WATER,
3752                                        ]),
3753                                        offset: [-1i32, -1i32, 0i32],
3754                                    },
3755                                    BlockPredicate::MatchingFluids {
3756                                        fluids: FluidRefList(vec![
3757                                            &vanilla_fluids::WATER,
3758                                            &vanilla_fluids::FLOWING_WATER,
3759                                        ]),
3760                                        offset: [0i32, -1i32, 1i32],
3761                                    },
3762                                    BlockPredicate::MatchingFluids {
3763                                        fluids: FluidRefList(vec![
3764                                            &vanilla_fluids::WATER,
3765                                            &vanilla_fluids::FLOWING_WATER,
3766                                        ]),
3767                                        offset: [0i32, -1i32, -1i32],
3768                                    },
3769                                ],
3770                            },
3771                        ],
3772                    },
3773                },
3774                PlacementModifier::Count {
3775                    count: IntProvider::Constant(20i32),
3776                },
3777                PlacementModifier::RandomOffset {
3778                    xz_spread: IntProvider::Trapezoid {
3779                        min: -4i32,
3780                        max: 4i32,
3781                        plateau: 0i32,
3782                    },
3783                    y_spread: IntProvider::Trapezoid {
3784                        min: -3i32,
3785                        max: 3i32,
3786                        plateau: 0i32,
3787                    },
3788                },
3789                PlacementModifier::BlockPredicateFilter {
3790                    predicate: BlockPredicate::MatchingBlockTag {
3791                        tag: Identifier::vanilla_static("air"),
3792                        offset: [0i32, 0i32, 0i32],
3793                    },
3794                },
3795            ],
3796        },
3797        id: OnceLock::new(),
3798    });
3799pub static PATCH_FIREFLY_BUSH_NEAR_WATER_SWAMP: LazyLock<PlacedFeature> =
3800    LazyLock::new(|| PlacedFeature {
3801        key: Identifier::vanilla_static("patch_firefly_bush_near_water_swamp"),
3802        data: PlacedFeatureData {
3803            feature: ConfiguredFeatureRef::Reference(
3804                &crate::vanilla_configured_features::FIREFLY_BUSH,
3805            ),
3806            placement: vec![
3807                PlacementModifier::Count {
3808                    count: IntProvider::Constant(3i32),
3809                },
3810                PlacementModifier::InSquare,
3811                PlacementModifier::Heightmap {
3812                    heightmap: FeatureHeightmap::MotionBlocking,
3813                },
3814                PlacementModifier::Biome,
3815                PlacementModifier::BlockPredicateFilter {
3816                    predicate: BlockPredicate::AllOf {
3817                        predicates: vec![
3818                            BlockPredicate::MatchingBlockTag {
3819                                tag: Identifier::vanilla_static("air"),
3820                                offset: [0i32, 0i32, 0i32],
3821                            },
3822                            BlockPredicate::WouldSurvive {
3823                                state: BlockStateData {
3824                                    block: &vanilla_blocks::FIREFLY_BUSH,
3825                                    properties: &[],
3826                                },
3827                                offset: [0i32, 0i32, 0i32],
3828                            },
3829                            BlockPredicate::AnyOf {
3830                                predicates: vec![
3831                                    BlockPredicate::MatchingFluids {
3832                                        fluids: FluidRefList(vec![
3833                                            &vanilla_fluids::WATER,
3834                                            &vanilla_fluids::FLOWING_WATER,
3835                                        ]),
3836                                        offset: [1i32, -1i32, 0i32],
3837                                    },
3838                                    BlockPredicate::MatchingFluids {
3839                                        fluids: FluidRefList(vec![
3840                                            &vanilla_fluids::WATER,
3841                                            &vanilla_fluids::FLOWING_WATER,
3842                                        ]),
3843                                        offset: [-1i32, -1i32, 0i32],
3844                                    },
3845                                    BlockPredicate::MatchingFluids {
3846                                        fluids: FluidRefList(vec![
3847                                            &vanilla_fluids::WATER,
3848                                            &vanilla_fluids::FLOWING_WATER,
3849                                        ]),
3850                                        offset: [0i32, -1i32, 1i32],
3851                                    },
3852                                    BlockPredicate::MatchingFluids {
3853                                        fluids: FluidRefList(vec![
3854                                            &vanilla_fluids::WATER,
3855                                            &vanilla_fluids::FLOWING_WATER,
3856                                        ]),
3857                                        offset: [0i32, -1i32, -1i32],
3858                                    },
3859                                ],
3860                            },
3861                        ],
3862                    },
3863                },
3864                PlacementModifier::Count {
3865                    count: IntProvider::Constant(20i32),
3866                },
3867                PlacementModifier::RandomOffset {
3868                    xz_spread: IntProvider::Trapezoid {
3869                        min: -4i32,
3870                        max: 4i32,
3871                        plateau: 0i32,
3872                    },
3873                    y_spread: IntProvider::Trapezoid {
3874                        min: -3i32,
3875                        max: 3i32,
3876                        plateau: 0i32,
3877                    },
3878                },
3879                PlacementModifier::BlockPredicateFilter {
3880                    predicate: BlockPredicate::MatchingBlockTag {
3881                        tag: Identifier::vanilla_static("air"),
3882                        offset: [0i32, 0i32, 0i32],
3883                    },
3884                },
3885            ],
3886        },
3887        id: OnceLock::new(),
3888    });
3889pub static PATCH_FIREFLY_BUSH_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3890    key: Identifier::vanilla_static("patch_firefly_bush_swamp"),
3891    data: PlacedFeatureData {
3892        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::FIREFLY_BUSH),
3893        placement: vec![
3894            PlacementModifier::RarityFilter { chance: 8i32 },
3895            PlacementModifier::InSquare,
3896            PlacementModifier::Heightmap {
3897                heightmap: FeatureHeightmap::MotionBlocking,
3898            },
3899            PlacementModifier::Biome,
3900            PlacementModifier::Count {
3901                count: IntProvider::Constant(20i32),
3902            },
3903            PlacementModifier::RandomOffset {
3904                xz_spread: IntProvider::Trapezoid {
3905                    min: -4i32,
3906                    max: 4i32,
3907                    plateau: 0i32,
3908                },
3909                y_spread: IntProvider::Trapezoid {
3910                    min: -3i32,
3911                    max: 3i32,
3912                    plateau: 0i32,
3913                },
3914            },
3915            PlacementModifier::BlockPredicateFilter {
3916                predicate: BlockPredicate::MatchingBlockTag {
3917                    tag: Identifier::vanilla_static("air"),
3918                    offset: [0i32, 0i32, 0i32],
3919                },
3920            },
3921        ],
3922    },
3923    id: OnceLock::new(),
3924});
3925pub static PATCH_GRASS_BADLANDS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3926    key: Identifier::vanilla_static("patch_grass_badlands"),
3927    data: PlacedFeatureData {
3928        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
3929        placement: vec![
3930            PlacementModifier::InSquare,
3931            PlacementModifier::Heightmap {
3932                heightmap: FeatureHeightmap::WorldSurfaceWg,
3933            },
3934            PlacementModifier::Biome,
3935            PlacementModifier::Count {
3936                count: IntProvider::Constant(32i32),
3937            },
3938            PlacementModifier::RandomOffset {
3939                xz_spread: IntProvider::Trapezoid {
3940                    min: -7i32,
3941                    max: 7i32,
3942                    plateau: 0i32,
3943                },
3944                y_spread: IntProvider::Trapezoid {
3945                    min: -3i32,
3946                    max: 3i32,
3947                    plateau: 0i32,
3948                },
3949            },
3950            PlacementModifier::BlockPredicateFilter {
3951                predicate: BlockPredicate::MatchingBlockTag {
3952                    tag: Identifier::vanilla_static("air"),
3953                    offset: [0i32, 0i32, 0i32],
3954                },
3955            },
3956        ],
3957    },
3958    id: OnceLock::new(),
3959});
3960pub static PATCH_GRASS_FOREST: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3961    key: Identifier::vanilla_static("patch_grass_forest"),
3962    data: PlacedFeatureData {
3963        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
3964        placement: vec![
3965            PlacementModifier::Count {
3966                count: IntProvider::Constant(2i32),
3967            },
3968            PlacementModifier::InSquare,
3969            PlacementModifier::Heightmap {
3970                heightmap: FeatureHeightmap::WorldSurfaceWg,
3971            },
3972            PlacementModifier::Biome,
3973            PlacementModifier::Count {
3974                count: IntProvider::Constant(32i32),
3975            },
3976            PlacementModifier::RandomOffset {
3977                xz_spread: IntProvider::Trapezoid {
3978                    min: -7i32,
3979                    max: 7i32,
3980                    plateau: 0i32,
3981                },
3982                y_spread: IntProvider::Trapezoid {
3983                    min: -3i32,
3984                    max: 3i32,
3985                    plateau: 0i32,
3986                },
3987            },
3988            PlacementModifier::BlockPredicateFilter {
3989                predicate: BlockPredicate::MatchingBlockTag {
3990                    tag: Identifier::vanilla_static("air"),
3991                    offset: [0i32, 0i32, 0i32],
3992                },
3993            },
3994        ],
3995    },
3996    id: OnceLock::new(),
3997});
3998pub static PATCH_GRASS_JUNGLE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
3999    key: Identifier::vanilla_static("patch_grass_jungle"),
4000    data: PlacedFeatureData {
4001        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS_JUNGLE),
4002        placement: vec![
4003            PlacementModifier::Count {
4004                count: IntProvider::Constant(25i32),
4005            },
4006            PlacementModifier::InSquare,
4007            PlacementModifier::Heightmap {
4008                heightmap: FeatureHeightmap::WorldSurfaceWg,
4009            },
4010            PlacementModifier::Biome,
4011            PlacementModifier::Count {
4012                count: IntProvider::Constant(32i32),
4013            },
4014            PlacementModifier::RandomOffset {
4015                xz_spread: IntProvider::Trapezoid {
4016                    min: -7i32,
4017                    max: 7i32,
4018                    plateau: 0i32,
4019                },
4020                y_spread: IntProvider::Trapezoid {
4021                    min: -3i32,
4022                    max: 3i32,
4023                    plateau: 0i32,
4024                },
4025            },
4026            PlacementModifier::BlockPredicateFilter {
4027                predicate: BlockPredicate::AllOf {
4028                    predicates: vec![
4029                        BlockPredicate::MatchingBlockTag {
4030                            tag: Identifier::vanilla_static("air"),
4031                            offset: [0i32, 0i32, 0i32],
4032                        },
4033                        BlockPredicate::Not {
4034                            predicate: Box::new(BlockPredicate::MatchingBlocks {
4035                                blocks: BlockRefList(vec![&vanilla_blocks::PODZOL]),
4036                                offset: [0i32, -1i32, 0i32],
4037                            }),
4038                        },
4039                    ],
4040                },
4041            },
4042        ],
4043    },
4044    id: OnceLock::new(),
4045});
4046pub static PATCH_GRASS_MEADOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4047    key: Identifier::vanilla_static("patch_grass_meadow"),
4048    data: PlacedFeatureData {
4049        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
4050        placement: vec![
4051            PlacementModifier::NoiseThresholdCount {
4052                noise_level: -0.8f64,
4053                below_noise: 5i32,
4054                above_noise: 10i32,
4055            },
4056            PlacementModifier::InSquare,
4057            PlacementModifier::Heightmap {
4058                heightmap: FeatureHeightmap::WorldSurfaceWg,
4059            },
4060            PlacementModifier::Biome,
4061            PlacementModifier::Count {
4062                count: IntProvider::Constant(16i32),
4063            },
4064            PlacementModifier::RandomOffset {
4065                xz_spread: IntProvider::Trapezoid {
4066                    min: -7i32,
4067                    max: 7i32,
4068                    plateau: 0i32,
4069                },
4070                y_spread: IntProvider::Trapezoid {
4071                    min: -3i32,
4072                    max: 3i32,
4073                    plateau: 0i32,
4074                },
4075            },
4076            PlacementModifier::BlockPredicateFilter {
4077                predicate: BlockPredicate::MatchingBlockTag {
4078                    tag: Identifier::vanilla_static("air"),
4079                    offset: [0i32, 0i32, 0i32],
4080                },
4081            },
4082        ],
4083    },
4084    id: OnceLock::new(),
4085});
4086pub static PATCH_GRASS_NORMAL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4087    key: Identifier::vanilla_static("patch_grass_normal"),
4088    data: PlacedFeatureData {
4089        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
4090        placement: vec![
4091            PlacementModifier::Count {
4092                count: IntProvider::Constant(5i32),
4093            },
4094            PlacementModifier::InSquare,
4095            PlacementModifier::Heightmap {
4096                heightmap: FeatureHeightmap::WorldSurfaceWg,
4097            },
4098            PlacementModifier::Biome,
4099            PlacementModifier::Count {
4100                count: IntProvider::Constant(32i32),
4101            },
4102            PlacementModifier::RandomOffset {
4103                xz_spread: IntProvider::Trapezoid {
4104                    min: -7i32,
4105                    max: 7i32,
4106                    plateau: 0i32,
4107                },
4108                y_spread: IntProvider::Trapezoid {
4109                    min: -3i32,
4110                    max: 3i32,
4111                    plateau: 0i32,
4112                },
4113            },
4114            PlacementModifier::BlockPredicateFilter {
4115                predicate: BlockPredicate::MatchingBlockTag {
4116                    tag: Identifier::vanilla_static("air"),
4117                    offset: [0i32, 0i32, 0i32],
4118                },
4119            },
4120        ],
4121    },
4122    id: OnceLock::new(),
4123});
4124pub static PATCH_GRASS_PLAIN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4125    key: Identifier::vanilla_static("patch_grass_plain"),
4126    data: PlacedFeatureData {
4127        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
4128        placement: vec![
4129            PlacementModifier::NoiseThresholdCount {
4130                noise_level: -0.8f64,
4131                below_noise: 5i32,
4132                above_noise: 10i32,
4133            },
4134            PlacementModifier::InSquare,
4135            PlacementModifier::Heightmap {
4136                heightmap: FeatureHeightmap::WorldSurfaceWg,
4137            },
4138            PlacementModifier::Biome,
4139            PlacementModifier::Count {
4140                count: IntProvider::Constant(32i32),
4141            },
4142            PlacementModifier::RandomOffset {
4143                xz_spread: IntProvider::Trapezoid {
4144                    min: -7i32,
4145                    max: 7i32,
4146                    plateau: 0i32,
4147                },
4148                y_spread: IntProvider::Trapezoid {
4149                    min: -3i32,
4150                    max: 3i32,
4151                    plateau: 0i32,
4152                },
4153            },
4154            PlacementModifier::BlockPredicateFilter {
4155                predicate: BlockPredicate::MatchingBlockTag {
4156                    tag: Identifier::vanilla_static("air"),
4157                    offset: [0i32, 0i32, 0i32],
4158                },
4159            },
4160        ],
4161    },
4162    id: OnceLock::new(),
4163});
4164pub static PATCH_GRASS_SAVANNA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4165    key: Identifier::vanilla_static("patch_grass_savanna"),
4166    data: PlacedFeatureData {
4167        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::GRASS),
4168        placement: vec![
4169            PlacementModifier::Count {
4170                count: IntProvider::Constant(20i32),
4171            },
4172            PlacementModifier::InSquare,
4173            PlacementModifier::Heightmap {
4174                heightmap: FeatureHeightmap::WorldSurfaceWg,
4175            },
4176            PlacementModifier::Biome,
4177            PlacementModifier::Count {
4178                count: IntProvider::Constant(32i32),
4179            },
4180            PlacementModifier::RandomOffset {
4181                xz_spread: IntProvider::Trapezoid {
4182                    min: -7i32,
4183                    max: 7i32,
4184                    plateau: 0i32,
4185                },
4186                y_spread: IntProvider::Trapezoid {
4187                    min: -3i32,
4188                    max: 3i32,
4189                    plateau: 0i32,
4190                },
4191            },
4192            PlacementModifier::BlockPredicateFilter {
4193                predicate: BlockPredicate::MatchingBlockTag {
4194                    tag: Identifier::vanilla_static("air"),
4195                    offset: [0i32, 0i32, 0i32],
4196                },
4197            },
4198        ],
4199    },
4200    id: OnceLock::new(),
4201});
4202pub static PATCH_GRASS_TAIGA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4203    key: Identifier::vanilla_static("patch_grass_taiga"),
4204    data: PlacedFeatureData {
4205        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TAIGA_GRASS),
4206        placement: vec![
4207            PlacementModifier::Count {
4208                count: IntProvider::Constant(7i32),
4209            },
4210            PlacementModifier::InSquare,
4211            PlacementModifier::Heightmap {
4212                heightmap: FeatureHeightmap::WorldSurfaceWg,
4213            },
4214            PlacementModifier::Biome,
4215            PlacementModifier::Count {
4216                count: IntProvider::Constant(32i32),
4217            },
4218            PlacementModifier::RandomOffset {
4219                xz_spread: IntProvider::Trapezoid {
4220                    min: -7i32,
4221                    max: 7i32,
4222                    plateau: 0i32,
4223                },
4224                y_spread: IntProvider::Trapezoid {
4225                    min: -3i32,
4226                    max: 3i32,
4227                    plateau: 0i32,
4228                },
4229            },
4230            PlacementModifier::BlockPredicateFilter {
4231                predicate: BlockPredicate::MatchingBlockTag {
4232                    tag: Identifier::vanilla_static("air"),
4233                    offset: [0i32, 0i32, 0i32],
4234                },
4235            },
4236        ],
4237    },
4238    id: OnceLock::new(),
4239});
4240pub static PATCH_GRASS_TAIGA_2: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4241    key: Identifier::vanilla_static("patch_grass_taiga_2"),
4242    data: PlacedFeatureData {
4243        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TAIGA_GRASS),
4244        placement: vec![
4245            PlacementModifier::InSquare,
4246            PlacementModifier::Heightmap {
4247                heightmap: FeatureHeightmap::WorldSurfaceWg,
4248            },
4249            PlacementModifier::Biome,
4250            PlacementModifier::Count {
4251                count: IntProvider::Constant(32i32),
4252            },
4253            PlacementModifier::RandomOffset {
4254                xz_spread: IntProvider::Trapezoid {
4255                    min: -7i32,
4256                    max: 7i32,
4257                    plateau: 0i32,
4258                },
4259                y_spread: IntProvider::Trapezoid {
4260                    min: -3i32,
4261                    max: 3i32,
4262                    plateau: 0i32,
4263                },
4264            },
4265            PlacementModifier::BlockPredicateFilter {
4266                predicate: BlockPredicate::MatchingBlockTag {
4267                    tag: Identifier::vanilla_static("air"),
4268                    offset: [0i32, 0i32, 0i32],
4269                },
4270            },
4271        ],
4272    },
4273    id: OnceLock::new(),
4274});
4275pub static PATCH_LARGE_FERN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4276    key: Identifier::vanilla_static("patch_large_fern"),
4277    data: PlacedFeatureData {
4278        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::LARGE_FERN),
4279        placement: vec![
4280            PlacementModifier::RarityFilter { chance: 5i32 },
4281            PlacementModifier::InSquare,
4282            PlacementModifier::Heightmap {
4283                heightmap: FeatureHeightmap::MotionBlocking,
4284            },
4285            PlacementModifier::Biome,
4286            PlacementModifier::Count {
4287                count: IntProvider::Constant(96i32),
4288            },
4289            PlacementModifier::RandomOffset {
4290                xz_spread: IntProvider::Trapezoid {
4291                    min: -7i32,
4292                    max: 7i32,
4293                    plateau: 0i32,
4294                },
4295                y_spread: IntProvider::Trapezoid {
4296                    min: -3i32,
4297                    max: 3i32,
4298                    plateau: 0i32,
4299                },
4300            },
4301            PlacementModifier::BlockPredicateFilter {
4302                predicate: BlockPredicate::MatchingBlockTag {
4303                    tag: Identifier::vanilla_static("air"),
4304                    offset: [0i32, 0i32, 0i32],
4305                },
4306            },
4307        ],
4308    },
4309    id: OnceLock::new(),
4310});
4311pub static PATCH_LEAF_LITTER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4312    key: Identifier::vanilla_static("patch_leaf_litter"),
4313    data: PlacedFeatureData {
4314        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::LEAF_LITTER),
4315        placement: vec![
4316            PlacementModifier::Count {
4317                count: IntProvider::Constant(2i32),
4318            },
4319            PlacementModifier::InSquare,
4320            PlacementModifier::Heightmap {
4321                heightmap: FeatureHeightmap::WorldSurfaceWg,
4322            },
4323            PlacementModifier::Biome,
4324            PlacementModifier::Count {
4325                count: IntProvider::Constant(32i32),
4326            },
4327            PlacementModifier::RandomOffset {
4328                xz_spread: IntProvider::Trapezoid {
4329                    min: -7i32,
4330                    max: 7i32,
4331                    plateau: 0i32,
4332                },
4333                y_spread: IntProvider::Trapezoid {
4334                    min: -3i32,
4335                    max: 3i32,
4336                    plateau: 0i32,
4337                },
4338            },
4339            PlacementModifier::BlockPredicateFilter {
4340                predicate: BlockPredicate::AllOf {
4341                    predicates: vec![
4342                        BlockPredicate::MatchingBlockTag {
4343                            tag: Identifier::vanilla_static("air"),
4344                            offset: [0i32, 0i32, 0i32],
4345                        },
4346                        BlockPredicate::MatchingBlocks {
4347                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
4348                            offset: [0i32, -1i32, 0i32],
4349                        },
4350                    ],
4351                },
4352            },
4353        ],
4354    },
4355    id: OnceLock::new(),
4356});
4357pub static PATCH_MELON: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4358    key: Identifier::vanilla_static("patch_melon"),
4359    data: PlacedFeatureData {
4360        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MELON),
4361        placement: vec![
4362            PlacementModifier::RarityFilter { chance: 6i32 },
4363            PlacementModifier::InSquare,
4364            PlacementModifier::Heightmap {
4365                heightmap: FeatureHeightmap::MotionBlocking,
4366            },
4367            PlacementModifier::Biome,
4368            PlacementModifier::Count {
4369                count: IntProvider::Constant(64i32),
4370            },
4371            PlacementModifier::RandomOffset {
4372                xz_spread: IntProvider::Trapezoid {
4373                    min: -7i32,
4374                    max: 7i32,
4375                    plateau: 0i32,
4376                },
4377                y_spread: IntProvider::Trapezoid {
4378                    min: -3i32,
4379                    max: 3i32,
4380                    plateau: 0i32,
4381                },
4382            },
4383            PlacementModifier::BlockPredicateFilter {
4384                predicate: BlockPredicate::AllOf {
4385                    predicates: vec![
4386                        BlockPredicate::Replaceable {
4387                            offset: [0i32, 0i32, 0i32],
4388                        },
4389                        BlockPredicate::MatchingFluids {
4390                            fluids: FluidRefList(vec![&vanilla_fluids::EMPTY]),
4391                            offset: [0i32, 0i32, 0i32],
4392                        },
4393                        BlockPredicate::MatchingBlocks {
4394                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
4395                            offset: [0i32, -1i32, 0i32],
4396                        },
4397                    ],
4398                },
4399            },
4400        ],
4401    },
4402    id: OnceLock::new(),
4403});
4404pub static PATCH_MELON_SPARSE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4405    key: Identifier::vanilla_static("patch_melon_sparse"),
4406    data: PlacedFeatureData {
4407        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MELON),
4408        placement: vec![
4409            PlacementModifier::RarityFilter { chance: 64i32 },
4410            PlacementModifier::InSquare,
4411            PlacementModifier::Heightmap {
4412                heightmap: FeatureHeightmap::MotionBlocking,
4413            },
4414            PlacementModifier::Biome,
4415            PlacementModifier::Count {
4416                count: IntProvider::Constant(64i32),
4417            },
4418            PlacementModifier::RandomOffset {
4419                xz_spread: IntProvider::Trapezoid {
4420                    min: -7i32,
4421                    max: 7i32,
4422                    plateau: 0i32,
4423                },
4424                y_spread: IntProvider::Trapezoid {
4425                    min: -3i32,
4426                    max: 3i32,
4427                    plateau: 0i32,
4428                },
4429            },
4430            PlacementModifier::BlockPredicateFilter {
4431                predicate: BlockPredicate::AllOf {
4432                    predicates: vec![
4433                        BlockPredicate::Replaceable {
4434                            offset: [0i32, 0i32, 0i32],
4435                        },
4436                        BlockPredicate::MatchingFluids {
4437                            fluids: FluidRefList(vec![&vanilla_fluids::EMPTY]),
4438                            offset: [0i32, 0i32, 0i32],
4439                        },
4440                        BlockPredicate::MatchingBlocks {
4441                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
4442                            offset: [0i32, -1i32, 0i32],
4443                        },
4444                    ],
4445                },
4446            },
4447        ],
4448    },
4449    id: OnceLock::new(),
4450});
4451pub static PATCH_PUMPKIN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4452    key: Identifier::vanilla_static("patch_pumpkin"),
4453    data: PlacedFeatureData {
4454        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PUMPKIN),
4455        placement: vec![
4456            PlacementModifier::RarityFilter { chance: 300i32 },
4457            PlacementModifier::InSquare,
4458            PlacementModifier::Heightmap {
4459                heightmap: FeatureHeightmap::MotionBlocking,
4460            },
4461            PlacementModifier::Biome,
4462            PlacementModifier::Count {
4463                count: IntProvider::Constant(96i32),
4464            },
4465            PlacementModifier::RandomOffset {
4466                xz_spread: IntProvider::Trapezoid {
4467                    min: -7i32,
4468                    max: 7i32,
4469                    plateau: 0i32,
4470                },
4471                y_spread: IntProvider::Trapezoid {
4472                    min: -3i32,
4473                    max: 3i32,
4474                    plateau: 0i32,
4475                },
4476            },
4477            PlacementModifier::BlockPredicateFilter {
4478                predicate: BlockPredicate::AllOf {
4479                    predicates: vec![
4480                        BlockPredicate::MatchingBlockTag {
4481                            tag: Identifier::vanilla_static("air"),
4482                            offset: [0i32, 0i32, 0i32],
4483                        },
4484                        BlockPredicate::MatchingBlocks {
4485                            blocks: BlockRefList(vec![&vanilla_blocks::GRASS_BLOCK]),
4486                            offset: [0i32, -1i32, 0i32],
4487                        },
4488                    ],
4489                },
4490            },
4491        ],
4492    },
4493    id: OnceLock::new(),
4494});
4495pub static PATCH_SOUL_FIRE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4496    key: Identifier::vanilla_static("patch_soul_fire"),
4497    data: PlacedFeatureData {
4498        feature: ConfiguredFeatureRef::Reference(
4499            &crate::vanilla_configured_features::PATCH_SOUL_FIRE,
4500        ),
4501        placement: vec![
4502            PlacementModifier::Count {
4503                count: IntProvider::Uniform {
4504                    min_inclusive: 0i32,
4505                    max_inclusive: 5i32,
4506                },
4507            },
4508            PlacementModifier::InSquare,
4509            PlacementModifier::HeightRange {
4510                height: HeightProvider::Uniform {
4511                    min_inclusive: VerticalAnchor::AboveBottom(4i32),
4512                    max_inclusive: VerticalAnchor::BelowTop(4i32),
4513                },
4514            },
4515            PlacementModifier::Biome,
4516            PlacementModifier::Count {
4517                count: IntProvider::Constant(96i32),
4518            },
4519            PlacementModifier::RandomOffset {
4520                xz_spread: IntProvider::Trapezoid {
4521                    min: -7i32,
4522                    max: 7i32,
4523                    plateau: 0i32,
4524                },
4525                y_spread: IntProvider::Trapezoid {
4526                    min: -3i32,
4527                    max: 3i32,
4528                    plateau: 0i32,
4529                },
4530            },
4531            PlacementModifier::BlockPredicateFilter {
4532                predicate: BlockPredicate::AllOf {
4533                    predicates: vec![
4534                        BlockPredicate::MatchingBlockTag {
4535                            tag: Identifier::vanilla_static("air"),
4536                            offset: [0i32, 0i32, 0i32],
4537                        },
4538                        BlockPredicate::MatchingBlocks {
4539                            blocks: BlockRefList(vec![&vanilla_blocks::SOUL_SOIL]),
4540                            offset: [0i32, -1i32, 0i32],
4541                        },
4542                    ],
4543                },
4544            },
4545        ],
4546    },
4547    id: OnceLock::new(),
4548});
4549pub static PATCH_SUGAR_CANE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4550    key: Identifier::vanilla_static("patch_sugar_cane"),
4551    data: PlacedFeatureData {
4552        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SUGAR_CANE),
4553        placement: vec![
4554            PlacementModifier::RarityFilter { chance: 6i32 },
4555            PlacementModifier::InSquare,
4556            PlacementModifier::Heightmap {
4557                heightmap: FeatureHeightmap::MotionBlocking,
4558            },
4559            PlacementModifier::Biome,
4560            PlacementModifier::Count {
4561                count: IntProvider::Constant(20i32),
4562            },
4563            PlacementModifier::RandomOffset {
4564                xz_spread: IntProvider::Trapezoid {
4565                    min: -4i32,
4566                    max: 4i32,
4567                    plateau: 0i32,
4568                },
4569                y_spread: IntProvider::Trapezoid {
4570                    min: 0i32,
4571                    max: 0i32,
4572                    plateau: 0i32,
4573                },
4574            },
4575            PlacementModifier::BlockPredicateFilter {
4576                predicate: BlockPredicate::AllOf {
4577                    predicates: vec![
4578                        BlockPredicate::MatchingBlockTag {
4579                            tag: Identifier::vanilla_static("air"),
4580                            offset: [0i32, 0i32, 0i32],
4581                        },
4582                        BlockPredicate::WouldSurvive {
4583                            state: BlockStateData {
4584                                block: &vanilla_blocks::SUGAR_CANE,
4585                                properties: &[("age", "0")],
4586                            },
4587                            offset: [0i32, 0i32, 0i32],
4588                        },
4589                        BlockPredicate::AnyOf {
4590                            predicates: vec![
4591                                BlockPredicate::MatchingFluids {
4592                                    fluids: FluidRefList(vec![
4593                                        &vanilla_fluids::WATER,
4594                                        &vanilla_fluids::FLOWING_WATER,
4595                                    ]),
4596                                    offset: [1i32, -1i32, 0i32],
4597                                },
4598                                BlockPredicate::MatchingFluids {
4599                                    fluids: FluidRefList(vec![
4600                                        &vanilla_fluids::WATER,
4601                                        &vanilla_fluids::FLOWING_WATER,
4602                                    ]),
4603                                    offset: [-1i32, -1i32, 0i32],
4604                                },
4605                                BlockPredicate::MatchingFluids {
4606                                    fluids: FluidRefList(vec![
4607                                        &vanilla_fluids::WATER,
4608                                        &vanilla_fluids::FLOWING_WATER,
4609                                    ]),
4610                                    offset: [0i32, -1i32, 1i32],
4611                                },
4612                                BlockPredicate::MatchingFluids {
4613                                    fluids: FluidRefList(vec![
4614                                        &vanilla_fluids::WATER,
4615                                        &vanilla_fluids::FLOWING_WATER,
4616                                    ]),
4617                                    offset: [0i32, -1i32, -1i32],
4618                                },
4619                            ],
4620                        },
4621                    ],
4622                },
4623            },
4624        ],
4625    },
4626    id: OnceLock::new(),
4627});
4628pub static PATCH_SUGAR_CANE_BADLANDS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4629    key: Identifier::vanilla_static("patch_sugar_cane_badlands"),
4630    data: PlacedFeatureData {
4631        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SUGAR_CANE),
4632        placement: vec![
4633            PlacementModifier::RarityFilter { chance: 5i32 },
4634            PlacementModifier::InSquare,
4635            PlacementModifier::Heightmap {
4636                heightmap: FeatureHeightmap::MotionBlocking,
4637            },
4638            PlacementModifier::Biome,
4639            PlacementModifier::Count {
4640                count: IntProvider::Constant(20i32),
4641            },
4642            PlacementModifier::RandomOffset {
4643                xz_spread: IntProvider::Trapezoid {
4644                    min: -4i32,
4645                    max: 4i32,
4646                    plateau: 0i32,
4647                },
4648                y_spread: IntProvider::Trapezoid {
4649                    min: 0i32,
4650                    max: 0i32,
4651                    plateau: 0i32,
4652                },
4653            },
4654            PlacementModifier::BlockPredicateFilter {
4655                predicate: BlockPredicate::AllOf {
4656                    predicates: vec![
4657                        BlockPredicate::MatchingBlockTag {
4658                            tag: Identifier::vanilla_static("air"),
4659                            offset: [0i32, 0i32, 0i32],
4660                        },
4661                        BlockPredicate::WouldSurvive {
4662                            state: BlockStateData {
4663                                block: &vanilla_blocks::SUGAR_CANE,
4664                                properties: &[("age", "0")],
4665                            },
4666                            offset: [0i32, 0i32, 0i32],
4667                        },
4668                        BlockPredicate::AnyOf {
4669                            predicates: vec![
4670                                BlockPredicate::MatchingFluids {
4671                                    fluids: FluidRefList(vec![
4672                                        &vanilla_fluids::WATER,
4673                                        &vanilla_fluids::FLOWING_WATER,
4674                                    ]),
4675                                    offset: [1i32, -1i32, 0i32],
4676                                },
4677                                BlockPredicate::MatchingFluids {
4678                                    fluids: FluidRefList(vec![
4679                                        &vanilla_fluids::WATER,
4680                                        &vanilla_fluids::FLOWING_WATER,
4681                                    ]),
4682                                    offset: [-1i32, -1i32, 0i32],
4683                                },
4684                                BlockPredicate::MatchingFluids {
4685                                    fluids: FluidRefList(vec![
4686                                        &vanilla_fluids::WATER,
4687                                        &vanilla_fluids::FLOWING_WATER,
4688                                    ]),
4689                                    offset: [0i32, -1i32, 1i32],
4690                                },
4691                                BlockPredicate::MatchingFluids {
4692                                    fluids: FluidRefList(vec![
4693                                        &vanilla_fluids::WATER,
4694                                        &vanilla_fluids::FLOWING_WATER,
4695                                    ]),
4696                                    offset: [0i32, -1i32, -1i32],
4697                                },
4698                            ],
4699                        },
4700                    ],
4701                },
4702            },
4703        ],
4704    },
4705    id: OnceLock::new(),
4706});
4707pub static PATCH_SUGAR_CANE_DESERT: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4708    key: Identifier::vanilla_static("patch_sugar_cane_desert"),
4709    data: PlacedFeatureData {
4710        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SUGAR_CANE),
4711        placement: vec![
4712            PlacementModifier::InSquare,
4713            PlacementModifier::Heightmap {
4714                heightmap: FeatureHeightmap::MotionBlocking,
4715            },
4716            PlacementModifier::Biome,
4717            PlacementModifier::Count {
4718                count: IntProvider::Constant(20i32),
4719            },
4720            PlacementModifier::RandomOffset {
4721                xz_spread: IntProvider::Trapezoid {
4722                    min: -4i32,
4723                    max: 4i32,
4724                    plateau: 0i32,
4725                },
4726                y_spread: IntProvider::Trapezoid {
4727                    min: 0i32,
4728                    max: 0i32,
4729                    plateau: 0i32,
4730                },
4731            },
4732            PlacementModifier::BlockPredicateFilter {
4733                predicate: BlockPredicate::AllOf {
4734                    predicates: vec![
4735                        BlockPredicate::MatchingBlockTag {
4736                            tag: Identifier::vanilla_static("air"),
4737                            offset: [0i32, 0i32, 0i32],
4738                        },
4739                        BlockPredicate::WouldSurvive {
4740                            state: BlockStateData {
4741                                block: &vanilla_blocks::SUGAR_CANE,
4742                                properties: &[("age", "0")],
4743                            },
4744                            offset: [0i32, 0i32, 0i32],
4745                        },
4746                        BlockPredicate::AnyOf {
4747                            predicates: vec![
4748                                BlockPredicate::MatchingFluids {
4749                                    fluids: FluidRefList(vec![
4750                                        &vanilla_fluids::WATER,
4751                                        &vanilla_fluids::FLOWING_WATER,
4752                                    ]),
4753                                    offset: [1i32, -1i32, 0i32],
4754                                },
4755                                BlockPredicate::MatchingFluids {
4756                                    fluids: FluidRefList(vec![
4757                                        &vanilla_fluids::WATER,
4758                                        &vanilla_fluids::FLOWING_WATER,
4759                                    ]),
4760                                    offset: [-1i32, -1i32, 0i32],
4761                                },
4762                                BlockPredicate::MatchingFluids {
4763                                    fluids: FluidRefList(vec![
4764                                        &vanilla_fluids::WATER,
4765                                        &vanilla_fluids::FLOWING_WATER,
4766                                    ]),
4767                                    offset: [0i32, -1i32, 1i32],
4768                                },
4769                                BlockPredicate::MatchingFluids {
4770                                    fluids: FluidRefList(vec![
4771                                        &vanilla_fluids::WATER,
4772                                        &vanilla_fluids::FLOWING_WATER,
4773                                    ]),
4774                                    offset: [0i32, -1i32, -1i32],
4775                                },
4776                            ],
4777                        },
4778                    ],
4779                },
4780            },
4781        ],
4782    },
4783    id: OnceLock::new(),
4784});
4785pub static PATCH_SUGAR_CANE_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4786    key: Identifier::vanilla_static("patch_sugar_cane_swamp"),
4787    data: PlacedFeatureData {
4788        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SUGAR_CANE),
4789        placement: vec![
4790            PlacementModifier::RarityFilter { chance: 3i32 },
4791            PlacementModifier::InSquare,
4792            PlacementModifier::Heightmap {
4793                heightmap: FeatureHeightmap::MotionBlocking,
4794            },
4795            PlacementModifier::Biome,
4796            PlacementModifier::Count {
4797                count: IntProvider::Constant(20i32),
4798            },
4799            PlacementModifier::RandomOffset {
4800                xz_spread: IntProvider::Trapezoid {
4801                    min: -4i32,
4802                    max: 4i32,
4803                    plateau: 0i32,
4804                },
4805                y_spread: IntProvider::Trapezoid {
4806                    min: 0i32,
4807                    max: 0i32,
4808                    plateau: 0i32,
4809                },
4810            },
4811            PlacementModifier::BlockPredicateFilter {
4812                predicate: BlockPredicate::AllOf {
4813                    predicates: vec![
4814                        BlockPredicate::MatchingBlockTag {
4815                            tag: Identifier::vanilla_static("air"),
4816                            offset: [0i32, 0i32, 0i32],
4817                        },
4818                        BlockPredicate::WouldSurvive {
4819                            state: BlockStateData {
4820                                block: &vanilla_blocks::SUGAR_CANE,
4821                                properties: &[("age", "0")],
4822                            },
4823                            offset: [0i32, 0i32, 0i32],
4824                        },
4825                        BlockPredicate::AnyOf {
4826                            predicates: vec![
4827                                BlockPredicate::MatchingFluids {
4828                                    fluids: FluidRefList(vec![
4829                                        &vanilla_fluids::WATER,
4830                                        &vanilla_fluids::FLOWING_WATER,
4831                                    ]),
4832                                    offset: [1i32, -1i32, 0i32],
4833                                },
4834                                BlockPredicate::MatchingFluids {
4835                                    fluids: FluidRefList(vec![
4836                                        &vanilla_fluids::WATER,
4837                                        &vanilla_fluids::FLOWING_WATER,
4838                                    ]),
4839                                    offset: [-1i32, -1i32, 0i32],
4840                                },
4841                                BlockPredicate::MatchingFluids {
4842                                    fluids: FluidRefList(vec![
4843                                        &vanilla_fluids::WATER,
4844                                        &vanilla_fluids::FLOWING_WATER,
4845                                    ]),
4846                                    offset: [0i32, -1i32, 1i32],
4847                                },
4848                                BlockPredicate::MatchingFluids {
4849                                    fluids: FluidRefList(vec![
4850                                        &vanilla_fluids::WATER,
4851                                        &vanilla_fluids::FLOWING_WATER,
4852                                    ]),
4853                                    offset: [0i32, -1i32, -1i32],
4854                                },
4855                            ],
4856                        },
4857                    ],
4858                },
4859            },
4860        ],
4861    },
4862    id: OnceLock::new(),
4863});
4864pub static PATCH_SUNFLOWER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4865    key: Identifier::vanilla_static("patch_sunflower"),
4866    data: PlacedFeatureData {
4867        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SUNFLOWER),
4868        placement: vec![
4869            PlacementModifier::RarityFilter { chance: 3i32 },
4870            PlacementModifier::InSquare,
4871            PlacementModifier::Heightmap {
4872                heightmap: FeatureHeightmap::MotionBlocking,
4873            },
4874            PlacementModifier::Biome,
4875            PlacementModifier::Count {
4876                count: IntProvider::Constant(96i32),
4877            },
4878            PlacementModifier::RandomOffset {
4879                xz_spread: IntProvider::Trapezoid {
4880                    min: -7i32,
4881                    max: 7i32,
4882                    plateau: 0i32,
4883                },
4884                y_spread: IntProvider::Trapezoid {
4885                    min: -3i32,
4886                    max: 3i32,
4887                    plateau: 0i32,
4888                },
4889            },
4890            PlacementModifier::BlockPredicateFilter {
4891                predicate: BlockPredicate::MatchingBlockTag {
4892                    tag: Identifier::vanilla_static("air"),
4893                    offset: [0i32, 0i32, 0i32],
4894                },
4895            },
4896        ],
4897    },
4898    id: OnceLock::new(),
4899});
4900pub static PATCH_TAIGA_GRASS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4901    key: Identifier::vanilla_static("patch_taiga_grass"),
4902    data: PlacedFeatureData {
4903        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TAIGA_GRASS),
4904        placement: vec![
4905            PlacementModifier::Count {
4906                count: IntProvider::Constant(32i32),
4907            },
4908            PlacementModifier::RandomOffset {
4909                xz_spread: IntProvider::Trapezoid {
4910                    min: -7i32,
4911                    max: 7i32,
4912                    plateau: 0i32,
4913                },
4914                y_spread: IntProvider::Trapezoid {
4915                    min: -3i32,
4916                    max: 3i32,
4917                    plateau: 0i32,
4918                },
4919            },
4920            PlacementModifier::BlockPredicateFilter {
4921                predicate: BlockPredicate::MatchingBlockTag {
4922                    tag: Identifier::vanilla_static("air"),
4923                    offset: [0i32, 0i32, 0i32],
4924                },
4925            },
4926        ],
4927    },
4928    id: OnceLock::new(),
4929});
4930pub static PATCH_TALL_GRASS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4931    key: Identifier::vanilla_static("patch_tall_grass"),
4932    data: PlacedFeatureData {
4933        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TALL_GRASS),
4934        placement: vec![
4935            PlacementModifier::RarityFilter { chance: 5i32 },
4936            PlacementModifier::InSquare,
4937            PlacementModifier::Heightmap {
4938                heightmap: FeatureHeightmap::MotionBlocking,
4939            },
4940            PlacementModifier::Biome,
4941            PlacementModifier::Count {
4942                count: IntProvider::Constant(96i32),
4943            },
4944            PlacementModifier::RandomOffset {
4945                xz_spread: IntProvider::Trapezoid {
4946                    min: -7i32,
4947                    max: 7i32,
4948                    plateau: 0i32,
4949                },
4950                y_spread: IntProvider::Trapezoid {
4951                    min: -3i32,
4952                    max: 3i32,
4953                    plateau: 0i32,
4954                },
4955            },
4956            PlacementModifier::BlockPredicateFilter {
4957                predicate: BlockPredicate::MatchingBlockTag {
4958                    tag: Identifier::vanilla_static("air"),
4959                    offset: [0i32, 0i32, 0i32],
4960                },
4961            },
4962        ],
4963    },
4964    id: OnceLock::new(),
4965});
4966pub static PATCH_TALL_GRASS_2: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
4967    key: Identifier::vanilla_static("patch_tall_grass_2"),
4968    data: PlacedFeatureData {
4969        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TALL_GRASS),
4970        placement: vec![
4971            PlacementModifier::NoiseThresholdCount {
4972                noise_level: -0.8f64,
4973                below_noise: 0i32,
4974                above_noise: 7i32,
4975            },
4976            PlacementModifier::RarityFilter { chance: 32i32 },
4977            PlacementModifier::InSquare,
4978            PlacementModifier::Heightmap {
4979                heightmap: FeatureHeightmap::MotionBlocking,
4980            },
4981            PlacementModifier::Biome,
4982            PlacementModifier::Count {
4983                count: IntProvider::Constant(96i32),
4984            },
4985            PlacementModifier::RandomOffset {
4986                xz_spread: IntProvider::Trapezoid {
4987                    min: -7i32,
4988                    max: 7i32,
4989                    plateau: 0i32,
4990                },
4991                y_spread: IntProvider::Trapezoid {
4992                    min: -3i32,
4993                    max: 3i32,
4994                    plateau: 0i32,
4995                },
4996            },
4997            PlacementModifier::BlockPredicateFilter {
4998                predicate: BlockPredicate::MatchingBlockTag {
4999                    tag: Identifier::vanilla_static("air"),
5000                    offset: [0i32, 0i32, 0i32],
5001                },
5002            },
5003        ],
5004    },
5005    id: OnceLock::new(),
5006});
5007pub static PATCH_WATERLILY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5008    key: Identifier::vanilla_static("patch_waterlily"),
5009    data: PlacedFeatureData {
5010        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::WATERLILY),
5011        placement: vec![
5012            PlacementModifier::Count {
5013                count: IntProvider::Constant(4i32),
5014            },
5015            PlacementModifier::InSquare,
5016            PlacementModifier::Heightmap {
5017                heightmap: FeatureHeightmap::WorldSurfaceWg,
5018            },
5019            PlacementModifier::Biome,
5020            PlacementModifier::Count {
5021                count: IntProvider::Constant(10i32),
5022            },
5023            PlacementModifier::RandomOffset {
5024                xz_spread: IntProvider::Trapezoid {
5025                    min: -7i32,
5026                    max: 7i32,
5027                    plateau: 0i32,
5028                },
5029                y_spread: IntProvider::Trapezoid {
5030                    min: -3i32,
5031                    max: 3i32,
5032                    plateau: 0i32,
5033                },
5034            },
5035            PlacementModifier::BlockPredicateFilter {
5036                predicate: BlockPredicate::MatchingBlockTag {
5037                    tag: Identifier::vanilla_static("air"),
5038                    offset: [0i32, 0i32, 0i32],
5039                },
5040            },
5041        ],
5042    },
5043    id: OnceLock::new(),
5044});
5045pub static PILE_HAY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5046    key: Identifier::vanilla_static("pile_hay"),
5047    data: PlacedFeatureData {
5048        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PILE_HAY),
5049        placement: vec![],
5050    },
5051    id: OnceLock::new(),
5052});
5053pub static PILE_ICE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5054    key: Identifier::vanilla_static("pile_ice"),
5055    data: PlacedFeatureData {
5056        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PILE_ICE),
5057        placement: vec![],
5058    },
5059    id: OnceLock::new(),
5060});
5061pub static PILE_MELON: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5062    key: Identifier::vanilla_static("pile_melon"),
5063    data: PlacedFeatureData {
5064        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PILE_MELON),
5065        placement: vec![],
5066    },
5067    id: OnceLock::new(),
5068});
5069pub static PILE_PUMPKIN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5070    key: Identifier::vanilla_static("pile_pumpkin"),
5071    data: PlacedFeatureData {
5072        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PILE_PUMPKIN),
5073        placement: vec![],
5074    },
5075    id: OnceLock::new(),
5076});
5077pub static PILE_SNOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5078    key: Identifier::vanilla_static("pile_snow"),
5079    data: PlacedFeatureData {
5080        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PILE_SNOW),
5081        placement: vec![],
5082    },
5083    id: OnceLock::new(),
5084});
5085pub static PINE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5086    key: Identifier::vanilla_static("pine"),
5087    data: PlacedFeatureData {
5088        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PINE),
5089        placement: vec![PlacementModifier::BlockPredicateFilter {
5090            predicate: BlockPredicate::WouldSurvive {
5091                state: BlockStateData {
5092                    block: &vanilla_blocks::SPRUCE_SAPLING,
5093                    properties: &[("stage", "0")],
5094                },
5095                offset: [0i32, 0i32, 0i32],
5096            },
5097        }],
5098    },
5099    id: OnceLock::new(),
5100});
5101pub static PINE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5102    key: Identifier::vanilla_static("pine_checked"),
5103    data: PlacedFeatureData {
5104        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PINE),
5105        placement: vec![PlacementModifier::BlockPredicateFilter {
5106            predicate: BlockPredicate::WouldSurvive {
5107                state: BlockStateData {
5108                    block: &vanilla_blocks::SPRUCE_SAPLING,
5109                    properties: &[("stage", "0")],
5110                },
5111                offset: [0i32, 0i32, 0i32],
5112            },
5113        }],
5114    },
5115    id: OnceLock::new(),
5116});
5117pub static PINE_ON_SNOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5118    key: Identifier::vanilla_static("pine_on_snow"),
5119    data: PlacedFeatureData {
5120        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::PINE),
5121        placement: vec![
5122            PlacementModifier::EnvironmentScan {
5123                direction_of_search: Direction::Up,
5124                target_condition: BlockPredicate::Not {
5125                    predicate: Box::new(BlockPredicate::MatchingBlocks {
5126                        blocks: BlockRefList(vec![&vanilla_blocks::POWDER_SNOW]),
5127                        offset: [0i32, 0i32, 0i32],
5128                    }),
5129                },
5130                allowed_search_condition: None,
5131                max_steps: 8i32,
5132            },
5133            PlacementModifier::BlockPredicateFilter {
5134                predicate: BlockPredicate::MatchingBlocks {
5135                    blocks: BlockRefList(vec![
5136                        &vanilla_blocks::SNOW_BLOCK,
5137                        &vanilla_blocks::POWDER_SNOW,
5138                    ]),
5139                    offset: [0i32, -1i32, 0i32],
5140                },
5141            },
5142        ],
5143    },
5144    id: OnceLock::new(),
5145});
5146pub static POINTED_DRIPSTONE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5147    key: Identifier::vanilla_static("pointed_dripstone"),
5148    data: PlacedFeatureData {
5149        feature: ConfiguredFeatureRef::Reference(
5150            &crate::vanilla_configured_features::POINTED_DRIPSTONE,
5151        ),
5152        placement: vec![
5153            PlacementModifier::Count {
5154                count: IntProvider::Uniform {
5155                    min_inclusive: 192i32,
5156                    max_inclusive: 256i32,
5157                },
5158            },
5159            PlacementModifier::InSquare,
5160            PlacementModifier::HeightRange {
5161                height: HeightProvider::Uniform {
5162                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5163                    max_inclusive: VerticalAnchor::Absolute(256i32),
5164                },
5165            },
5166            PlacementModifier::Count {
5167                count: IntProvider::Uniform {
5168                    min_inclusive: 1i32,
5169                    max_inclusive: 5i32,
5170                },
5171            },
5172            PlacementModifier::RandomOffset {
5173                xz_spread: IntProvider::ClampedNormal {
5174                    mean: 0f32,
5175                    deviation: 3f32,
5176                    min_inclusive: -10i32,
5177                    max_inclusive: 10i32,
5178                },
5179                y_spread: IntProvider::ClampedNormal {
5180                    mean: 0f32,
5181                    deviation: 0.6f32,
5182                    min_inclusive: -2i32,
5183                    max_inclusive: 2i32,
5184                },
5185            },
5186            PlacementModifier::Biome,
5187        ],
5188    },
5189    id: OnceLock::new(),
5190});
5191pub static RED_MUSHROOM_NETHER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5192    key: Identifier::vanilla_static("red_mushroom_nether"),
5193    data: PlacedFeatureData {
5194        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::RED_MUSHROOM),
5195        placement: vec![
5196            PlacementModifier::RarityFilter { chance: 2i32 },
5197            PlacementModifier::InSquare,
5198            PlacementModifier::HeightRange {
5199                height: HeightProvider::Uniform {
5200                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5201                    max_inclusive: VerticalAnchor::BelowTop(0i32),
5202                },
5203            },
5204            PlacementModifier::Biome,
5205            PlacementModifier::Count {
5206                count: IntProvider::Constant(96i32),
5207            },
5208            PlacementModifier::RandomOffset {
5209                xz_spread: IntProvider::Trapezoid {
5210                    min: -7i32,
5211                    max: 7i32,
5212                    plateau: 0i32,
5213                },
5214                y_spread: IntProvider::Trapezoid {
5215                    min: -3i32,
5216                    max: 3i32,
5217                    plateau: 0i32,
5218                },
5219            },
5220            PlacementModifier::BlockPredicateFilter {
5221                predicate: BlockPredicate::MatchingBlockTag {
5222                    tag: Identifier::vanilla_static("air"),
5223                    offset: [0i32, 0i32, 0i32],
5224                },
5225            },
5226        ],
5227    },
5228    id: OnceLock::new(),
5229});
5230pub static RED_MUSHROOM_NORMAL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5231    key: Identifier::vanilla_static("red_mushroom_normal"),
5232    data: PlacedFeatureData {
5233        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::RED_MUSHROOM),
5234        placement: vec![
5235            PlacementModifier::RarityFilter { chance: 512i32 },
5236            PlacementModifier::InSquare,
5237            PlacementModifier::Heightmap {
5238                heightmap: FeatureHeightmap::MotionBlocking,
5239            },
5240            PlacementModifier::Biome,
5241            PlacementModifier::Count {
5242                count: IntProvider::Constant(96i32),
5243            },
5244            PlacementModifier::RandomOffset {
5245                xz_spread: IntProvider::Trapezoid {
5246                    min: -7i32,
5247                    max: 7i32,
5248                    plateau: 0i32,
5249                },
5250                y_spread: IntProvider::Trapezoid {
5251                    min: -3i32,
5252                    max: 3i32,
5253                    plateau: 0i32,
5254                },
5255            },
5256            PlacementModifier::BlockPredicateFilter {
5257                predicate: BlockPredicate::MatchingBlockTag {
5258                    tag: Identifier::vanilla_static("air"),
5259                    offset: [0i32, 0i32, 0i32],
5260                },
5261            },
5262        ],
5263    },
5264    id: OnceLock::new(),
5265});
5266pub static RED_MUSHROOM_OLD_GROWTH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5267    key: Identifier::vanilla_static("red_mushroom_old_growth"),
5268    data: PlacedFeatureData {
5269        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::RED_MUSHROOM),
5270        placement: vec![
5271            PlacementModifier::RarityFilter { chance: 171i32 },
5272            PlacementModifier::InSquare,
5273            PlacementModifier::Heightmap {
5274                heightmap: FeatureHeightmap::MotionBlocking,
5275            },
5276            PlacementModifier::Biome,
5277            PlacementModifier::Count {
5278                count: IntProvider::Constant(96i32),
5279            },
5280            PlacementModifier::RandomOffset {
5281                xz_spread: IntProvider::Trapezoid {
5282                    min: -7i32,
5283                    max: 7i32,
5284                    plateau: 0i32,
5285                },
5286                y_spread: IntProvider::Trapezoid {
5287                    min: -3i32,
5288                    max: 3i32,
5289                    plateau: 0i32,
5290                },
5291            },
5292            PlacementModifier::BlockPredicateFilter {
5293                predicate: BlockPredicate::MatchingBlockTag {
5294                    tag: Identifier::vanilla_static("air"),
5295                    offset: [0i32, 0i32, 0i32],
5296                },
5297            },
5298        ],
5299    },
5300    id: OnceLock::new(),
5301});
5302pub static RED_MUSHROOM_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5303    key: Identifier::vanilla_static("red_mushroom_swamp"),
5304    data: PlacedFeatureData {
5305        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::RED_MUSHROOM),
5306        placement: vec![
5307            PlacementModifier::RarityFilter { chance: 64i32 },
5308            PlacementModifier::InSquare,
5309            PlacementModifier::Heightmap {
5310                heightmap: FeatureHeightmap::MotionBlocking,
5311            },
5312            PlacementModifier::Biome,
5313            PlacementModifier::Count {
5314                count: IntProvider::Constant(96i32),
5315            },
5316            PlacementModifier::RandomOffset {
5317                xz_spread: IntProvider::Trapezoid {
5318                    min: -7i32,
5319                    max: 7i32,
5320                    plateau: 0i32,
5321                },
5322                y_spread: IntProvider::Trapezoid {
5323                    min: -3i32,
5324                    max: 3i32,
5325                    plateau: 0i32,
5326                },
5327            },
5328            PlacementModifier::BlockPredicateFilter {
5329                predicate: BlockPredicate::MatchingBlockTag {
5330                    tag: Identifier::vanilla_static("air"),
5331                    offset: [0i32, 0i32, 0i32],
5332                },
5333            },
5334        ],
5335    },
5336    id: OnceLock::new(),
5337});
5338pub static RED_MUSHROOM_TAIGA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5339    key: Identifier::vanilla_static("red_mushroom_taiga"),
5340    data: PlacedFeatureData {
5341        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::RED_MUSHROOM),
5342        placement: vec![
5343            PlacementModifier::RarityFilter { chance: 256i32 },
5344            PlacementModifier::InSquare,
5345            PlacementModifier::Heightmap {
5346                heightmap: FeatureHeightmap::MotionBlocking,
5347            },
5348            PlacementModifier::Biome,
5349            PlacementModifier::Count {
5350                count: IntProvider::Constant(96i32),
5351            },
5352            PlacementModifier::RandomOffset {
5353                xz_spread: IntProvider::Trapezoid {
5354                    min: -7i32,
5355                    max: 7i32,
5356                    plateau: 0i32,
5357                },
5358                y_spread: IntProvider::Trapezoid {
5359                    min: -3i32,
5360                    max: 3i32,
5361                    plateau: 0i32,
5362                },
5363            },
5364            PlacementModifier::BlockPredicateFilter {
5365                predicate: BlockPredicate::MatchingBlockTag {
5366                    tag: Identifier::vanilla_static("air"),
5367                    offset: [0i32, 0i32, 0i32],
5368                },
5369            },
5370        ],
5371    },
5372    id: OnceLock::new(),
5373});
5374pub static ROOTED_AZALEA_TREE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5375    key: Identifier::vanilla_static("rooted_azalea_tree"),
5376    data: PlacedFeatureData {
5377        feature: ConfiguredFeatureRef::Reference(
5378            &crate::vanilla_configured_features::ROOTED_AZALEA_TREE,
5379        ),
5380        placement: vec![
5381            PlacementModifier::Count {
5382                count: IntProvider::Uniform {
5383                    min_inclusive: 1i32,
5384                    max_inclusive: 2i32,
5385                },
5386            },
5387            PlacementModifier::InSquare,
5388            PlacementModifier::HeightRange {
5389                height: HeightProvider::Uniform {
5390                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5391                    max_inclusive: VerticalAnchor::Absolute(256i32),
5392                },
5393            },
5394            PlacementModifier::EnvironmentScan {
5395                direction_of_search: Direction::Up,
5396                target_condition: BlockPredicate::Solid {
5397                    offset: [0i32, 0i32, 0i32],
5398                },
5399                allowed_search_condition: Some(BlockPredicate::MatchingBlockTag {
5400                    tag: Identifier::vanilla_static("air"),
5401                    offset: [0i32, 0i32, 0i32],
5402                }),
5403                max_steps: 12i32,
5404            },
5405            PlacementModifier::RandomOffset {
5406                xz_spread: IntProvider::Constant(0i32),
5407                y_spread: IntProvider::Constant(-1i32),
5408            },
5409            PlacementModifier::Biome,
5410        ],
5411    },
5412    id: OnceLock::new(),
5413});
5414pub static SCULK_PATCH_ANCIENT_CITY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5415    key: Identifier::vanilla_static("sculk_patch_ancient_city"),
5416    data: PlacedFeatureData {
5417        feature: ConfiguredFeatureRef::Reference(
5418            &crate::vanilla_configured_features::SCULK_PATCH_ANCIENT_CITY,
5419        ),
5420        placement: vec![],
5421    },
5422    id: OnceLock::new(),
5423});
5424pub static SCULK_PATCH_DEEP_DARK: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5425    key: Identifier::vanilla_static("sculk_patch_deep_dark"),
5426    data: PlacedFeatureData {
5427        feature: ConfiguredFeatureRef::Reference(
5428            &crate::vanilla_configured_features::SCULK_PATCH_DEEP_DARK,
5429        ),
5430        placement: vec![
5431            PlacementModifier::Count {
5432                count: IntProvider::Constant(256i32),
5433            },
5434            PlacementModifier::InSquare,
5435            PlacementModifier::HeightRange {
5436                height: HeightProvider::Uniform {
5437                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5438                    max_inclusive: VerticalAnchor::Absolute(256i32),
5439                },
5440            },
5441            PlacementModifier::Biome,
5442        ],
5443    },
5444    id: OnceLock::new(),
5445});
5446pub static SCULK_VEIN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5447    key: Identifier::vanilla_static("sculk_vein"),
5448    data: PlacedFeatureData {
5449        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SCULK_VEIN),
5450        placement: vec![
5451            PlacementModifier::Count {
5452                count: IntProvider::Uniform {
5453                    min_inclusive: 204i32,
5454                    max_inclusive: 250i32,
5455                },
5456            },
5457            PlacementModifier::InSquare,
5458            PlacementModifier::HeightRange {
5459                height: HeightProvider::Uniform {
5460                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5461                    max_inclusive: VerticalAnchor::Absolute(256i32),
5462                },
5463            },
5464            PlacementModifier::Biome,
5465        ],
5466    },
5467    id: OnceLock::new(),
5468});
5469pub static SEA_PICKLE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5470    key: Identifier::vanilla_static("sea_pickle"),
5471    data: PlacedFeatureData {
5472        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SEA_PICKLE),
5473        placement: vec![
5474            PlacementModifier::RarityFilter { chance: 16i32 },
5475            PlacementModifier::InSquare,
5476            PlacementModifier::Heightmap {
5477                heightmap: FeatureHeightmap::OceanFloorWg,
5478            },
5479            PlacementModifier::Biome,
5480        ],
5481    },
5482    id: OnceLock::new(),
5483});
5484pub static SEAGRASS_COLD: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5485    key: Identifier::vanilla_static("seagrass_cold"),
5486    data: PlacedFeatureData {
5487        feature: ConfiguredFeatureRef::Reference(
5488            &crate::vanilla_configured_features::SEAGRASS_SHORT,
5489        ),
5490        placement: vec![
5491            PlacementModifier::InSquare,
5492            PlacementModifier::Heightmap {
5493                heightmap: FeatureHeightmap::OceanFloorWg,
5494            },
5495            PlacementModifier::Count {
5496                count: IntProvider::Constant(32i32),
5497            },
5498            PlacementModifier::Biome,
5499        ],
5500    },
5501    id: OnceLock::new(),
5502});
5503pub static SEAGRASS_DEEP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5504    key: Identifier::vanilla_static("seagrass_deep"),
5505    data: PlacedFeatureData {
5506        feature: ConfiguredFeatureRef::Reference(
5507            &crate::vanilla_configured_features::SEAGRASS_TALL,
5508        ),
5509        placement: vec![
5510            PlacementModifier::InSquare,
5511            PlacementModifier::Heightmap {
5512                heightmap: FeatureHeightmap::OceanFloorWg,
5513            },
5514            PlacementModifier::Count {
5515                count: IntProvider::Constant(48i32),
5516            },
5517            PlacementModifier::Biome,
5518        ],
5519    },
5520    id: OnceLock::new(),
5521});
5522pub static SEAGRASS_DEEP_COLD: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5523    key: Identifier::vanilla_static("seagrass_deep_cold"),
5524    data: PlacedFeatureData {
5525        feature: ConfiguredFeatureRef::Reference(
5526            &crate::vanilla_configured_features::SEAGRASS_TALL,
5527        ),
5528        placement: vec![
5529            PlacementModifier::InSquare,
5530            PlacementModifier::Heightmap {
5531                heightmap: FeatureHeightmap::OceanFloorWg,
5532            },
5533            PlacementModifier::Count {
5534                count: IntProvider::Constant(40i32),
5535            },
5536            PlacementModifier::Biome,
5537        ],
5538    },
5539    id: OnceLock::new(),
5540});
5541pub static SEAGRASS_DEEP_WARM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5542    key: Identifier::vanilla_static("seagrass_deep_warm"),
5543    data: PlacedFeatureData {
5544        feature: ConfiguredFeatureRef::Reference(
5545            &crate::vanilla_configured_features::SEAGRASS_TALL,
5546        ),
5547        placement: vec![
5548            PlacementModifier::InSquare,
5549            PlacementModifier::Heightmap {
5550                heightmap: FeatureHeightmap::OceanFloorWg,
5551            },
5552            PlacementModifier::Count {
5553                count: IntProvider::Constant(80i32),
5554            },
5555            PlacementModifier::Biome,
5556        ],
5557    },
5558    id: OnceLock::new(),
5559});
5560pub static SEAGRASS_NORMAL: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5561    key: Identifier::vanilla_static("seagrass_normal"),
5562    data: PlacedFeatureData {
5563        feature: ConfiguredFeatureRef::Reference(
5564            &crate::vanilla_configured_features::SEAGRASS_SHORT,
5565        ),
5566        placement: vec![
5567            PlacementModifier::InSquare,
5568            PlacementModifier::Heightmap {
5569                heightmap: FeatureHeightmap::OceanFloorWg,
5570            },
5571            PlacementModifier::Count {
5572                count: IntProvider::Constant(48i32),
5573            },
5574            PlacementModifier::Biome,
5575        ],
5576    },
5577    id: OnceLock::new(),
5578});
5579pub static SEAGRASS_RIVER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5580    key: Identifier::vanilla_static("seagrass_river"),
5581    data: PlacedFeatureData {
5582        feature: ConfiguredFeatureRef::Reference(
5583            &crate::vanilla_configured_features::SEAGRASS_SLIGHTLY_LESS_SHORT,
5584        ),
5585        placement: vec![
5586            PlacementModifier::InSquare,
5587            PlacementModifier::Heightmap {
5588                heightmap: FeatureHeightmap::OceanFloorWg,
5589            },
5590            PlacementModifier::Count {
5591                count: IntProvider::Constant(48i32),
5592            },
5593            PlacementModifier::Biome,
5594        ],
5595    },
5596    id: OnceLock::new(),
5597});
5598pub static SEAGRASS_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5599    key: Identifier::vanilla_static("seagrass_swamp"),
5600    data: PlacedFeatureData {
5601        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SEAGRASS_MID),
5602        placement: vec![
5603            PlacementModifier::InSquare,
5604            PlacementModifier::Heightmap {
5605                heightmap: FeatureHeightmap::OceanFloorWg,
5606            },
5607            PlacementModifier::Count {
5608                count: IntProvider::Constant(64i32),
5609            },
5610            PlacementModifier::Biome,
5611        ],
5612    },
5613    id: OnceLock::new(),
5614});
5615pub static SEAGRASS_WARM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5616    key: Identifier::vanilla_static("seagrass_warm"),
5617    data: PlacedFeatureData {
5618        feature: ConfiguredFeatureRef::Reference(
5619            &crate::vanilla_configured_features::SEAGRASS_SHORT,
5620        ),
5621        placement: vec![
5622            PlacementModifier::InSquare,
5623            PlacementModifier::Heightmap {
5624                heightmap: FeatureHeightmap::OceanFloorWg,
5625            },
5626            PlacementModifier::Count {
5627                count: IntProvider::Constant(80i32),
5628            },
5629            PlacementModifier::Biome,
5630        ],
5631    },
5632    id: OnceLock::new(),
5633});
5634pub static SMALL_BASALT_COLUMNS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5635    key: Identifier::vanilla_static("small_basalt_columns"),
5636    data: PlacedFeatureData {
5637        feature: ConfiguredFeatureRef::Reference(
5638            &crate::vanilla_configured_features::SMALL_BASALT_COLUMNS,
5639        ),
5640        placement: vec![
5641            PlacementModifier::CountOnEveryLayer {
5642                count: IntProvider::Constant(4i32),
5643            },
5644            PlacementModifier::Biome,
5645        ],
5646    },
5647    id: OnceLock::new(),
5648});
5649pub static SPORE_BLOSSOM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5650    key: Identifier::vanilla_static("spore_blossom"),
5651    data: PlacedFeatureData {
5652        feature: ConfiguredFeatureRef::Reference(
5653            &crate::vanilla_configured_features::SPORE_BLOSSOM,
5654        ),
5655        placement: vec![
5656            PlacementModifier::Count {
5657                count: IntProvider::Constant(25i32),
5658            },
5659            PlacementModifier::InSquare,
5660            PlacementModifier::HeightRange {
5661                height: HeightProvider::Uniform {
5662                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5663                    max_inclusive: VerticalAnchor::Absolute(256i32),
5664                },
5665            },
5666            PlacementModifier::EnvironmentScan {
5667                direction_of_search: Direction::Up,
5668                target_condition: BlockPredicate::Solid {
5669                    offset: [0i32, 0i32, 0i32],
5670                },
5671                allowed_search_condition: Some(BlockPredicate::MatchingBlockTag {
5672                    tag: Identifier::vanilla_static("air"),
5673                    offset: [0i32, 0i32, 0i32],
5674                }),
5675                max_steps: 12i32,
5676            },
5677            PlacementModifier::RandomOffset {
5678                xz_spread: IntProvider::Constant(0i32),
5679                y_spread: IntProvider::Constant(-1i32),
5680            },
5681            PlacementModifier::Biome,
5682        ],
5683    },
5684    id: OnceLock::new(),
5685});
5686pub static SPRING_CLOSED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5687    key: Identifier::vanilla_static("spring_closed"),
5688    data: PlacedFeatureData {
5689        feature: ConfiguredFeatureRef::Reference(
5690            &crate::vanilla_configured_features::SPRING_NETHER_CLOSED,
5691        ),
5692        placement: vec![
5693            PlacementModifier::Count {
5694                count: IntProvider::Constant(16i32),
5695            },
5696            PlacementModifier::InSquare,
5697            PlacementModifier::HeightRange {
5698                height: HeightProvider::Uniform {
5699                    min_inclusive: VerticalAnchor::AboveBottom(10i32),
5700                    max_inclusive: VerticalAnchor::BelowTop(10i32),
5701                },
5702            },
5703            PlacementModifier::Biome,
5704        ],
5705    },
5706    id: OnceLock::new(),
5707});
5708pub static SPRING_CLOSED_DOUBLE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5709    key: Identifier::vanilla_static("spring_closed_double"),
5710    data: PlacedFeatureData {
5711        feature: ConfiguredFeatureRef::Reference(
5712            &crate::vanilla_configured_features::SPRING_NETHER_CLOSED,
5713        ),
5714        placement: vec![
5715            PlacementModifier::Count {
5716                count: IntProvider::Constant(32i32),
5717            },
5718            PlacementModifier::InSquare,
5719            PlacementModifier::HeightRange {
5720                height: HeightProvider::Uniform {
5721                    min_inclusive: VerticalAnchor::AboveBottom(10i32),
5722                    max_inclusive: VerticalAnchor::BelowTop(10i32),
5723                },
5724            },
5725            PlacementModifier::Biome,
5726        ],
5727    },
5728    id: OnceLock::new(),
5729});
5730pub static SPRING_DELTA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5731    key: Identifier::vanilla_static("spring_delta"),
5732    data: PlacedFeatureData {
5733        feature: ConfiguredFeatureRef::Reference(
5734            &crate::vanilla_configured_features::SPRING_LAVA_NETHER,
5735        ),
5736        placement: vec![
5737            PlacementModifier::Count {
5738                count: IntProvider::Constant(16i32),
5739            },
5740            PlacementModifier::InSquare,
5741            PlacementModifier::HeightRange {
5742                height: HeightProvider::Uniform {
5743                    min_inclusive: VerticalAnchor::AboveBottom(4i32),
5744                    max_inclusive: VerticalAnchor::BelowTop(4i32),
5745                },
5746            },
5747            PlacementModifier::Biome,
5748        ],
5749    },
5750    id: OnceLock::new(),
5751});
5752pub static SPRING_LAVA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5753    key: Identifier::vanilla_static("spring_lava"),
5754    data: PlacedFeatureData {
5755        feature: ConfiguredFeatureRef::Reference(
5756            &crate::vanilla_configured_features::SPRING_LAVA_OVERWORLD,
5757        ),
5758        placement: vec![
5759            PlacementModifier::Count {
5760                count: IntProvider::Constant(20i32),
5761            },
5762            PlacementModifier::InSquare,
5763            PlacementModifier::HeightRange {
5764                height: HeightProvider::VeryBiasedToBottom {
5765                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5766                    max_inclusive: VerticalAnchor::BelowTop(8i32),
5767                    inner: 8i32,
5768                },
5769            },
5770            PlacementModifier::Biome,
5771        ],
5772    },
5773    id: OnceLock::new(),
5774});
5775pub static SPRING_LAVA_FROZEN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5776    key: Identifier::vanilla_static("spring_lava_frozen"),
5777    data: PlacedFeatureData {
5778        feature: ConfiguredFeatureRef::Reference(
5779            &crate::vanilla_configured_features::SPRING_LAVA_FROZEN,
5780        ),
5781        placement: vec![
5782            PlacementModifier::Count {
5783                count: IntProvider::Constant(20i32),
5784            },
5785            PlacementModifier::InSquare,
5786            PlacementModifier::HeightRange {
5787                height: HeightProvider::VeryBiasedToBottom {
5788                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5789                    max_inclusive: VerticalAnchor::BelowTop(8i32),
5790                    inner: 8i32,
5791                },
5792            },
5793            PlacementModifier::Biome,
5794        ],
5795    },
5796    id: OnceLock::new(),
5797});
5798pub static SPRING_OPEN: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5799    key: Identifier::vanilla_static("spring_open"),
5800    data: PlacedFeatureData {
5801        feature: ConfiguredFeatureRef::Reference(
5802            &crate::vanilla_configured_features::SPRING_NETHER_OPEN,
5803        ),
5804        placement: vec![
5805            PlacementModifier::Count {
5806                count: IntProvider::Constant(8i32),
5807            },
5808            PlacementModifier::InSquare,
5809            PlacementModifier::HeightRange {
5810                height: HeightProvider::Uniform {
5811                    min_inclusive: VerticalAnchor::AboveBottom(4i32),
5812                    max_inclusive: VerticalAnchor::BelowTop(4i32),
5813                },
5814            },
5815            PlacementModifier::Biome,
5816        ],
5817    },
5818    id: OnceLock::new(),
5819});
5820pub static SPRING_WATER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5821    key: Identifier::vanilla_static("spring_water"),
5822    data: PlacedFeatureData {
5823        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SPRING_WATER),
5824        placement: vec![
5825            PlacementModifier::Count {
5826                count: IntProvider::Constant(25i32),
5827            },
5828            PlacementModifier::InSquare,
5829            PlacementModifier::HeightRange {
5830                height: HeightProvider::Uniform {
5831                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
5832                    max_inclusive: VerticalAnchor::Absolute(192i32),
5833                },
5834            },
5835            PlacementModifier::Biome,
5836        ],
5837    },
5838    id: OnceLock::new(),
5839});
5840pub static SPRUCE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5841    key: Identifier::vanilla_static("spruce"),
5842    data: PlacedFeatureData {
5843        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SPRUCE),
5844        placement: vec![PlacementModifier::BlockPredicateFilter {
5845            predicate: BlockPredicate::WouldSurvive {
5846                state: BlockStateData {
5847                    block: &vanilla_blocks::SPRUCE_SAPLING,
5848                    properties: &[("stage", "0")],
5849                },
5850                offset: [0i32, 0i32, 0i32],
5851            },
5852        }],
5853    },
5854    id: OnceLock::new(),
5855});
5856pub static SPRUCE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5857    key: Identifier::vanilla_static("spruce_checked"),
5858    data: PlacedFeatureData {
5859        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SPRUCE),
5860        placement: vec![PlacementModifier::BlockPredicateFilter {
5861            predicate: BlockPredicate::WouldSurvive {
5862                state: BlockStateData {
5863                    block: &vanilla_blocks::SPRUCE_SAPLING,
5864                    properties: &[("stage", "0")],
5865                },
5866                offset: [0i32, 0i32, 0i32],
5867            },
5868        }],
5869    },
5870    id: OnceLock::new(),
5871});
5872pub static SPRUCE_ON_SNOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5873    key: Identifier::vanilla_static("spruce_on_snow"),
5874    data: PlacedFeatureData {
5875        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SPRUCE),
5876        placement: vec![
5877            PlacementModifier::EnvironmentScan {
5878                direction_of_search: Direction::Up,
5879                target_condition: BlockPredicate::Not {
5880                    predicate: Box::new(BlockPredicate::MatchingBlocks {
5881                        blocks: BlockRefList(vec![&vanilla_blocks::POWDER_SNOW]),
5882                        offset: [0i32, 0i32, 0i32],
5883                    }),
5884                },
5885                allowed_search_condition: None,
5886                max_steps: 8i32,
5887            },
5888            PlacementModifier::BlockPredicateFilter {
5889                predicate: BlockPredicate::MatchingBlocks {
5890                    blocks: BlockRefList(vec![
5891                        &vanilla_blocks::SNOW_BLOCK,
5892                        &vanilla_blocks::POWDER_SNOW,
5893                    ]),
5894                    offset: [0i32, -1i32, 0i32],
5895                },
5896            },
5897        ],
5898    },
5899    id: OnceLock::new(),
5900});
5901pub static SUPER_BIRCH_BEES: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5902    key: Identifier::vanilla_static("super_birch_bees"),
5903    data: PlacedFeatureData {
5904        feature: ConfiguredFeatureRef::Reference(
5905            &crate::vanilla_configured_features::SUPER_BIRCH_BEES,
5906        ),
5907        placement: vec![PlacementModifier::BlockPredicateFilter {
5908            predicate: BlockPredicate::WouldSurvive {
5909                state: BlockStateData {
5910                    block: &vanilla_blocks::BIRCH_SAPLING,
5911                    properties: &[("stage", "0")],
5912                },
5913                offset: [0i32, 0i32, 0i32],
5914            },
5915        }],
5916    },
5917    id: OnceLock::new(),
5918});
5919pub static SUPER_BIRCH_BEES_0002: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5920    key: Identifier::vanilla_static("super_birch_bees_0002"),
5921    data: PlacedFeatureData {
5922        feature: ConfiguredFeatureRef::Reference(
5923            &crate::vanilla_configured_features::SUPER_BIRCH_BEES_0002,
5924        ),
5925        placement: vec![PlacementModifier::BlockPredicateFilter {
5926            predicate: BlockPredicate::WouldSurvive {
5927                state: BlockStateData {
5928                    block: &vanilla_blocks::BIRCH_SAPLING,
5929                    properties: &[("stage", "0")],
5930                },
5931                offset: [0i32, 0i32, 0i32],
5932            },
5933        }],
5934    },
5935    id: OnceLock::new(),
5936});
5937pub static TALL_MANGROVE_CHECKED: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5938    key: Identifier::vanilla_static("tall_mangrove_checked"),
5939    data: PlacedFeatureData {
5940        feature: ConfiguredFeatureRef::Reference(
5941            &crate::vanilla_configured_features::TALL_MANGROVE,
5942        ),
5943        placement: vec![PlacementModifier::BlockPredicateFilter {
5944            predicate: BlockPredicate::WouldSurvive {
5945                state: BlockStateData {
5946                    block: &vanilla_blocks::MANGROVE_PROPAGULE,
5947                    properties: &[
5948                        ("age", "0"),
5949                        ("hanging", "false"),
5950                        ("stage", "0"),
5951                        ("waterlogged", "false"),
5952                    ],
5953                },
5954                offset: [0i32, 0i32, 0i32],
5955            },
5956        }],
5957    },
5958    id: OnceLock::new(),
5959});
5960pub static TREES_BADLANDS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
5961    key: Identifier::vanilla_static("trees_badlands"),
5962    data: PlacedFeatureData {
5963        feature: ConfiguredFeatureRef::Reference(
5964            &crate::vanilla_configured_features::TREES_BADLANDS,
5965        ),
5966        placement: vec![
5967            PlacementModifier::Count {
5968                count: IntProvider::WeightedList {
5969                    distribution: vec![
5970                        WeightedIntProvider {
5971                            data: IntProvider::Constant(5i32),
5972                            weight: 9i32,
5973                        },
5974                        WeightedIntProvider {
5975                            data: IntProvider::Constant(6i32),
5976                            weight: 1i32,
5977                        },
5978                    ],
5979                },
5980            },
5981            PlacementModifier::InSquare,
5982            PlacementModifier::SurfaceWaterDepthFilter {
5983                max_water_depth: 0i32,
5984            },
5985            PlacementModifier::Heightmap {
5986                heightmap: FeatureHeightmap::OceanFloor,
5987            },
5988            PlacementModifier::Biome,
5989            PlacementModifier::BlockPredicateFilter {
5990                predicate: BlockPredicate::WouldSurvive {
5991                    state: BlockStateData {
5992                        block: &vanilla_blocks::OAK_SAPLING,
5993                        properties: &[("stage", "0")],
5994                    },
5995                    offset: [0i32, 0i32, 0i32],
5996                },
5997            },
5998        ],
5999    },
6000    id: OnceLock::new(),
6001});
6002pub static TREES_BIRCH: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6003    key: Identifier::vanilla_static("trees_birch"),
6004    data: PlacedFeatureData {
6005        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_BIRCH),
6006        placement: vec![
6007            PlacementModifier::Count {
6008                count: IntProvider::WeightedList {
6009                    distribution: vec![
6010                        WeightedIntProvider {
6011                            data: IntProvider::Constant(10i32),
6012                            weight: 9i32,
6013                        },
6014                        WeightedIntProvider {
6015                            data: IntProvider::Constant(11i32),
6016                            weight: 1i32,
6017                        },
6018                    ],
6019                },
6020            },
6021            PlacementModifier::InSquare,
6022            PlacementModifier::SurfaceWaterDepthFilter {
6023                max_water_depth: 0i32,
6024            },
6025            PlacementModifier::Heightmap {
6026                heightmap: FeatureHeightmap::OceanFloor,
6027            },
6028            PlacementModifier::Biome,
6029            PlacementModifier::BlockPredicateFilter {
6030                predicate: BlockPredicate::WouldSurvive {
6031                    state: BlockStateData {
6032                        block: &vanilla_blocks::BIRCH_SAPLING,
6033                        properties: &[("stage", "0")],
6034                    },
6035                    offset: [0i32, 0i32, 0i32],
6036                },
6037            },
6038        ],
6039    },
6040    id: OnceLock::new(),
6041});
6042pub static TREES_BIRCH_AND_OAK_LEAF_LITTER: LazyLock<PlacedFeature> =
6043    LazyLock::new(|| PlacedFeature {
6044        key: Identifier::vanilla_static("trees_birch_and_oak_leaf_litter"),
6045        data: PlacedFeatureData {
6046            feature: ConfiguredFeatureRef::Reference(
6047                &crate::vanilla_configured_features::TREES_BIRCH_AND_OAK_LEAF_LITTER,
6048            ),
6049            placement: vec![
6050                PlacementModifier::Count {
6051                    count: IntProvider::WeightedList {
6052                        distribution: vec![
6053                            WeightedIntProvider {
6054                                data: IntProvider::Constant(10i32),
6055                                weight: 9i32,
6056                            },
6057                            WeightedIntProvider {
6058                                data: IntProvider::Constant(11i32),
6059                                weight: 1i32,
6060                            },
6061                        ],
6062                    },
6063                },
6064                PlacementModifier::InSquare,
6065                PlacementModifier::SurfaceWaterDepthFilter {
6066                    max_water_depth: 0i32,
6067                },
6068                PlacementModifier::Heightmap {
6069                    heightmap: FeatureHeightmap::OceanFloor,
6070                },
6071                PlacementModifier::Biome,
6072            ],
6073        },
6074        id: OnceLock::new(),
6075    });
6076pub static TREES_CHERRY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6077    key: Identifier::vanilla_static("trees_cherry"),
6078    data: PlacedFeatureData {
6079        feature: ConfiguredFeatureRef::Reference(
6080            &crate::vanilla_configured_features::CHERRY_BEES_005,
6081        ),
6082        placement: vec![
6083            PlacementModifier::Count {
6084                count: IntProvider::WeightedList {
6085                    distribution: vec![
6086                        WeightedIntProvider {
6087                            data: IntProvider::Constant(10i32),
6088                            weight: 9i32,
6089                        },
6090                        WeightedIntProvider {
6091                            data: IntProvider::Constant(11i32),
6092                            weight: 1i32,
6093                        },
6094                    ],
6095                },
6096            },
6097            PlacementModifier::InSquare,
6098            PlacementModifier::SurfaceWaterDepthFilter {
6099                max_water_depth: 0i32,
6100            },
6101            PlacementModifier::Heightmap {
6102                heightmap: FeatureHeightmap::OceanFloor,
6103            },
6104            PlacementModifier::Biome,
6105            PlacementModifier::BlockPredicateFilter {
6106                predicate: BlockPredicate::WouldSurvive {
6107                    state: BlockStateData {
6108                        block: &vanilla_blocks::CHERRY_SAPLING,
6109                        properties: &[("stage", "0")],
6110                    },
6111                    offset: [0i32, 0i32, 0i32],
6112                },
6113            },
6114        ],
6115    },
6116    id: OnceLock::new(),
6117});
6118pub static TREES_FLOWER_FOREST: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6119    key: Identifier::vanilla_static("trees_flower_forest"),
6120    data: PlacedFeatureData {
6121        feature: ConfiguredFeatureRef::Reference(
6122            &crate::vanilla_configured_features::TREES_FLOWER_FOREST,
6123        ),
6124        placement: vec![
6125            PlacementModifier::Count {
6126                count: IntProvider::WeightedList {
6127                    distribution: vec![
6128                        WeightedIntProvider {
6129                            data: IntProvider::Constant(6i32),
6130                            weight: 9i32,
6131                        },
6132                        WeightedIntProvider {
6133                            data: IntProvider::Constant(7i32),
6134                            weight: 1i32,
6135                        },
6136                    ],
6137                },
6138            },
6139            PlacementModifier::InSquare,
6140            PlacementModifier::SurfaceWaterDepthFilter {
6141                max_water_depth: 0i32,
6142            },
6143            PlacementModifier::Heightmap {
6144                heightmap: FeatureHeightmap::OceanFloor,
6145            },
6146            PlacementModifier::Biome,
6147        ],
6148    },
6149    id: OnceLock::new(),
6150});
6151pub static TREES_GROVE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6152    key: Identifier::vanilla_static("trees_grove"),
6153    data: PlacedFeatureData {
6154        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_GROVE),
6155        placement: vec![
6156            PlacementModifier::Count {
6157                count: IntProvider::WeightedList {
6158                    distribution: vec![
6159                        WeightedIntProvider {
6160                            data: IntProvider::Constant(10i32),
6161                            weight: 9i32,
6162                        },
6163                        WeightedIntProvider {
6164                            data: IntProvider::Constant(11i32),
6165                            weight: 1i32,
6166                        },
6167                    ],
6168                },
6169            },
6170            PlacementModifier::InSquare,
6171            PlacementModifier::SurfaceWaterDepthFilter {
6172                max_water_depth: 0i32,
6173            },
6174            PlacementModifier::Heightmap {
6175                heightmap: FeatureHeightmap::OceanFloor,
6176            },
6177            PlacementModifier::Biome,
6178        ],
6179    },
6180    id: OnceLock::new(),
6181});
6182pub static TREES_JUNGLE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6183    key: Identifier::vanilla_static("trees_jungle"),
6184    data: PlacedFeatureData {
6185        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_JUNGLE),
6186        placement: vec![
6187            PlacementModifier::Count {
6188                count: IntProvider::WeightedList {
6189                    distribution: vec![
6190                        WeightedIntProvider {
6191                            data: IntProvider::Constant(50i32),
6192                            weight: 9i32,
6193                        },
6194                        WeightedIntProvider {
6195                            data: IntProvider::Constant(51i32),
6196                            weight: 1i32,
6197                        },
6198                    ],
6199                },
6200            },
6201            PlacementModifier::InSquare,
6202            PlacementModifier::SurfaceWaterDepthFilter {
6203                max_water_depth: 0i32,
6204            },
6205            PlacementModifier::Heightmap {
6206                heightmap: FeatureHeightmap::OceanFloor,
6207            },
6208            PlacementModifier::Biome,
6209        ],
6210    },
6211    id: OnceLock::new(),
6212});
6213pub static TREES_MANGROVE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6214    key: Identifier::vanilla_static("trees_mangrove"),
6215    data: PlacedFeatureData {
6216        feature: ConfiguredFeatureRef::Reference(
6217            &crate::vanilla_configured_features::MANGROVE_VEGETATION,
6218        ),
6219        placement: vec![
6220            PlacementModifier::Count {
6221                count: IntProvider::Constant(25i32),
6222            },
6223            PlacementModifier::InSquare,
6224            PlacementModifier::SurfaceWaterDepthFilter {
6225                max_water_depth: 5i32,
6226            },
6227            PlacementModifier::Heightmap {
6228                heightmap: FeatureHeightmap::OceanFloor,
6229            },
6230            PlacementModifier::Biome,
6231        ],
6232    },
6233    id: OnceLock::new(),
6234});
6235pub static TREES_MEADOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6236    key: Identifier::vanilla_static("trees_meadow"),
6237    data: PlacedFeatureData {
6238        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::MEADOW_TREES),
6239        placement: vec![
6240            PlacementModifier::RarityFilter { chance: 100i32 },
6241            PlacementModifier::InSquare,
6242            PlacementModifier::SurfaceWaterDepthFilter {
6243                max_water_depth: 0i32,
6244            },
6245            PlacementModifier::Heightmap {
6246                heightmap: FeatureHeightmap::OceanFloor,
6247            },
6248            PlacementModifier::Biome,
6249        ],
6250    },
6251    id: OnceLock::new(),
6252});
6253pub static TREES_OLD_GROWTH_PINE_TAIGA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6254    key: Identifier::vanilla_static("trees_old_growth_pine_taiga"),
6255    data: PlacedFeatureData {
6256        feature: ConfiguredFeatureRef::Reference(
6257            &crate::vanilla_configured_features::TREES_OLD_GROWTH_PINE_TAIGA,
6258        ),
6259        placement: vec![
6260            PlacementModifier::Count {
6261                count: IntProvider::WeightedList {
6262                    distribution: vec![
6263                        WeightedIntProvider {
6264                            data: IntProvider::Constant(10i32),
6265                            weight: 9i32,
6266                        },
6267                        WeightedIntProvider {
6268                            data: IntProvider::Constant(11i32),
6269                            weight: 1i32,
6270                        },
6271                    ],
6272                },
6273            },
6274            PlacementModifier::InSquare,
6275            PlacementModifier::SurfaceWaterDepthFilter {
6276                max_water_depth: 0i32,
6277            },
6278            PlacementModifier::Heightmap {
6279                heightmap: FeatureHeightmap::OceanFloor,
6280            },
6281            PlacementModifier::Biome,
6282        ],
6283    },
6284    id: OnceLock::new(),
6285});
6286pub static TREES_OLD_GROWTH_SPRUCE_TAIGA: LazyLock<PlacedFeature> =
6287    LazyLock::new(|| PlacedFeature {
6288        key: Identifier::vanilla_static("trees_old_growth_spruce_taiga"),
6289        data: PlacedFeatureData {
6290            feature: ConfiguredFeatureRef::Reference(
6291                &crate::vanilla_configured_features::TREES_OLD_GROWTH_SPRUCE_TAIGA,
6292            ),
6293            placement: vec![
6294                PlacementModifier::Count {
6295                    count: IntProvider::WeightedList {
6296                        distribution: vec![
6297                            WeightedIntProvider {
6298                                data: IntProvider::Constant(10i32),
6299                                weight: 9i32,
6300                            },
6301                            WeightedIntProvider {
6302                                data: IntProvider::Constant(11i32),
6303                                weight: 1i32,
6304                            },
6305                        ],
6306                    },
6307                },
6308                PlacementModifier::InSquare,
6309                PlacementModifier::SurfaceWaterDepthFilter {
6310                    max_water_depth: 0i32,
6311                },
6312                PlacementModifier::Heightmap {
6313                    heightmap: FeatureHeightmap::OceanFloor,
6314                },
6315                PlacementModifier::Biome,
6316            ],
6317        },
6318        id: OnceLock::new(),
6319    });
6320pub static TREES_PLAINS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6321    key: Identifier::vanilla_static("trees_plains"),
6322    data: PlacedFeatureData {
6323        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_PLAINS),
6324        placement: vec![
6325            PlacementModifier::Count {
6326                count: IntProvider::WeightedList {
6327                    distribution: vec![
6328                        WeightedIntProvider {
6329                            data: IntProvider::Constant(0i32),
6330                            weight: 19i32,
6331                        },
6332                        WeightedIntProvider {
6333                            data: IntProvider::Constant(1i32),
6334                            weight: 1i32,
6335                        },
6336                    ],
6337                },
6338            },
6339            PlacementModifier::InSquare,
6340            PlacementModifier::SurfaceWaterDepthFilter {
6341                max_water_depth: 0i32,
6342            },
6343            PlacementModifier::Heightmap {
6344                heightmap: FeatureHeightmap::OceanFloor,
6345            },
6346            PlacementModifier::BlockPredicateFilter {
6347                predicate: BlockPredicate::WouldSurvive {
6348                    state: BlockStateData {
6349                        block: &vanilla_blocks::OAK_SAPLING,
6350                        properties: &[("stage", "0")],
6351                    },
6352                    offset: [0i32, 0i32, 0i32],
6353                },
6354            },
6355            PlacementModifier::Biome,
6356        ],
6357    },
6358    id: OnceLock::new(),
6359});
6360pub static TREES_SAVANNA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6361    key: Identifier::vanilla_static("trees_savanna"),
6362    data: PlacedFeatureData {
6363        feature: ConfiguredFeatureRef::Reference(
6364            &crate::vanilla_configured_features::TREES_SAVANNA,
6365        ),
6366        placement: vec![
6367            PlacementModifier::Count {
6368                count: IntProvider::WeightedList {
6369                    distribution: vec![
6370                        WeightedIntProvider {
6371                            data: IntProvider::Constant(1i32),
6372                            weight: 9i32,
6373                        },
6374                        WeightedIntProvider {
6375                            data: IntProvider::Constant(2i32),
6376                            weight: 1i32,
6377                        },
6378                    ],
6379                },
6380            },
6381            PlacementModifier::InSquare,
6382            PlacementModifier::SurfaceWaterDepthFilter {
6383                max_water_depth: 0i32,
6384            },
6385            PlacementModifier::Heightmap {
6386                heightmap: FeatureHeightmap::OceanFloor,
6387            },
6388            PlacementModifier::Biome,
6389        ],
6390    },
6391    id: OnceLock::new(),
6392});
6393pub static TREES_SNOWY: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6394    key: Identifier::vanilla_static("trees_snowy"),
6395    data: PlacedFeatureData {
6396        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_SNOWY),
6397        placement: vec![
6398            PlacementModifier::Count {
6399                count: IntProvider::WeightedList {
6400                    distribution: vec![
6401                        WeightedIntProvider {
6402                            data: IntProvider::Constant(0i32),
6403                            weight: 9i32,
6404                        },
6405                        WeightedIntProvider {
6406                            data: IntProvider::Constant(1i32),
6407                            weight: 1i32,
6408                        },
6409                    ],
6410                },
6411            },
6412            PlacementModifier::InSquare,
6413            PlacementModifier::SurfaceWaterDepthFilter {
6414                max_water_depth: 0i32,
6415            },
6416            PlacementModifier::Heightmap {
6417                heightmap: FeatureHeightmap::OceanFloor,
6418            },
6419            PlacementModifier::Biome,
6420            PlacementModifier::BlockPredicateFilter {
6421                predicate: BlockPredicate::WouldSurvive {
6422                    state: BlockStateData {
6423                        block: &vanilla_blocks::SPRUCE_SAPLING,
6424                        properties: &[("stage", "0")],
6425                    },
6426                    offset: [0i32, 0i32, 0i32],
6427                },
6428            },
6429        ],
6430    },
6431    id: OnceLock::new(),
6432});
6433pub static TREES_SPARSE_JUNGLE: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6434    key: Identifier::vanilla_static("trees_sparse_jungle"),
6435    data: PlacedFeatureData {
6436        feature: ConfiguredFeatureRef::Reference(
6437            &crate::vanilla_configured_features::TREES_SPARSE_JUNGLE,
6438        ),
6439        placement: vec![
6440            PlacementModifier::Count {
6441                count: IntProvider::WeightedList {
6442                    distribution: vec![
6443                        WeightedIntProvider {
6444                            data: IntProvider::Constant(2i32),
6445                            weight: 9i32,
6446                        },
6447                        WeightedIntProvider {
6448                            data: IntProvider::Constant(3i32),
6449                            weight: 1i32,
6450                        },
6451                    ],
6452                },
6453            },
6454            PlacementModifier::InSquare,
6455            PlacementModifier::SurfaceWaterDepthFilter {
6456                max_water_depth: 0i32,
6457            },
6458            PlacementModifier::Heightmap {
6459                heightmap: FeatureHeightmap::OceanFloor,
6460            },
6461            PlacementModifier::Biome,
6462        ],
6463    },
6464    id: OnceLock::new(),
6465});
6466pub static TREES_SWAMP: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6467    key: Identifier::vanilla_static("trees_swamp"),
6468    data: PlacedFeatureData {
6469        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::SWAMP_OAK),
6470        placement: vec![
6471            PlacementModifier::Count {
6472                count: IntProvider::WeightedList {
6473                    distribution: vec![
6474                        WeightedIntProvider {
6475                            data: IntProvider::Constant(2i32),
6476                            weight: 9i32,
6477                        },
6478                        WeightedIntProvider {
6479                            data: IntProvider::Constant(3i32),
6480                            weight: 1i32,
6481                        },
6482                    ],
6483                },
6484            },
6485            PlacementModifier::InSquare,
6486            PlacementModifier::SurfaceWaterDepthFilter {
6487                max_water_depth: 2i32,
6488            },
6489            PlacementModifier::Heightmap {
6490                heightmap: FeatureHeightmap::OceanFloor,
6491            },
6492            PlacementModifier::Biome,
6493            PlacementModifier::BlockPredicateFilter {
6494                predicate: BlockPredicate::WouldSurvive {
6495                    state: BlockStateData {
6496                        block: &vanilla_blocks::OAK_SAPLING,
6497                        properties: &[("stage", "0")],
6498                    },
6499                    offset: [0i32, 0i32, 0i32],
6500                },
6501            },
6502        ],
6503    },
6504    id: OnceLock::new(),
6505});
6506pub static TREES_TAIGA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6507    key: Identifier::vanilla_static("trees_taiga"),
6508    data: PlacedFeatureData {
6509        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_TAIGA),
6510        placement: vec![
6511            PlacementModifier::Count {
6512                count: IntProvider::WeightedList {
6513                    distribution: vec![
6514                        WeightedIntProvider {
6515                            data: IntProvider::Constant(10i32),
6516                            weight: 9i32,
6517                        },
6518                        WeightedIntProvider {
6519                            data: IntProvider::Constant(11i32),
6520                            weight: 1i32,
6521                        },
6522                    ],
6523                },
6524            },
6525            PlacementModifier::InSquare,
6526            PlacementModifier::SurfaceWaterDepthFilter {
6527                max_water_depth: 0i32,
6528            },
6529            PlacementModifier::Heightmap {
6530                heightmap: FeatureHeightmap::OceanFloor,
6531            },
6532            PlacementModifier::Biome,
6533        ],
6534    },
6535    id: OnceLock::new(),
6536});
6537pub static TREES_WATER: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6538    key: Identifier::vanilla_static("trees_water"),
6539    data: PlacedFeatureData {
6540        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::TREES_WATER),
6541        placement: vec![
6542            PlacementModifier::Count {
6543                count: IntProvider::WeightedList {
6544                    distribution: vec![
6545                        WeightedIntProvider {
6546                            data: IntProvider::Constant(0i32),
6547                            weight: 9i32,
6548                        },
6549                        WeightedIntProvider {
6550                            data: IntProvider::Constant(1i32),
6551                            weight: 1i32,
6552                        },
6553                    ],
6554                },
6555            },
6556            PlacementModifier::InSquare,
6557            PlacementModifier::SurfaceWaterDepthFilter {
6558                max_water_depth: 0i32,
6559            },
6560            PlacementModifier::Heightmap {
6561                heightmap: FeatureHeightmap::OceanFloor,
6562            },
6563            PlacementModifier::Biome,
6564        ],
6565    },
6566    id: OnceLock::new(),
6567});
6568pub static TREES_WINDSWEPT_FOREST: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6569    key: Identifier::vanilla_static("trees_windswept_forest"),
6570    data: PlacedFeatureData {
6571        feature: ConfiguredFeatureRef::Reference(
6572            &crate::vanilla_configured_features::TREES_WINDSWEPT_HILLS,
6573        ),
6574        placement: vec![
6575            PlacementModifier::Count {
6576                count: IntProvider::WeightedList {
6577                    distribution: vec![
6578                        WeightedIntProvider {
6579                            data: IntProvider::Constant(3i32),
6580                            weight: 9i32,
6581                        },
6582                        WeightedIntProvider {
6583                            data: IntProvider::Constant(4i32),
6584                            weight: 1i32,
6585                        },
6586                    ],
6587                },
6588            },
6589            PlacementModifier::InSquare,
6590            PlacementModifier::SurfaceWaterDepthFilter {
6591                max_water_depth: 0i32,
6592            },
6593            PlacementModifier::Heightmap {
6594                heightmap: FeatureHeightmap::OceanFloor,
6595            },
6596            PlacementModifier::Biome,
6597        ],
6598    },
6599    id: OnceLock::new(),
6600});
6601pub static TREES_WINDSWEPT_HILLS: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6602    key: Identifier::vanilla_static("trees_windswept_hills"),
6603    data: PlacedFeatureData {
6604        feature: ConfiguredFeatureRef::Reference(
6605            &crate::vanilla_configured_features::TREES_WINDSWEPT_HILLS,
6606        ),
6607        placement: vec![
6608            PlacementModifier::Count {
6609                count: IntProvider::WeightedList {
6610                    distribution: vec![
6611                        WeightedIntProvider {
6612                            data: IntProvider::Constant(0i32),
6613                            weight: 9i32,
6614                        },
6615                        WeightedIntProvider {
6616                            data: IntProvider::Constant(1i32),
6617                            weight: 1i32,
6618                        },
6619                    ],
6620                },
6621            },
6622            PlacementModifier::InSquare,
6623            PlacementModifier::SurfaceWaterDepthFilter {
6624                max_water_depth: 0i32,
6625            },
6626            PlacementModifier::Heightmap {
6627                heightmap: FeatureHeightmap::OceanFloor,
6628            },
6629            PlacementModifier::Biome,
6630        ],
6631    },
6632    id: OnceLock::new(),
6633});
6634pub static TREES_WINDSWEPT_SAVANNA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6635    key: Identifier::vanilla_static("trees_windswept_savanna"),
6636    data: PlacedFeatureData {
6637        feature: ConfiguredFeatureRef::Reference(
6638            &crate::vanilla_configured_features::TREES_SAVANNA,
6639        ),
6640        placement: vec![
6641            PlacementModifier::Count {
6642                count: IntProvider::WeightedList {
6643                    distribution: vec![
6644                        WeightedIntProvider {
6645                            data: IntProvider::Constant(2i32),
6646                            weight: 9i32,
6647                        },
6648                        WeightedIntProvider {
6649                            data: IntProvider::Constant(3i32),
6650                            weight: 1i32,
6651                        },
6652                    ],
6653                },
6654            },
6655            PlacementModifier::InSquare,
6656            PlacementModifier::SurfaceWaterDepthFilter {
6657                max_water_depth: 0i32,
6658            },
6659            PlacementModifier::Heightmap {
6660                heightmap: FeatureHeightmap::OceanFloor,
6661            },
6662            PlacementModifier::Biome,
6663        ],
6664    },
6665    id: OnceLock::new(),
6666});
6667pub static TWISTING_VINES: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6668    key: Identifier::vanilla_static("twisting_vines"),
6669    data: PlacedFeatureData {
6670        feature: ConfiguredFeatureRef::Reference(
6671            &crate::vanilla_configured_features::TWISTING_VINES,
6672        ),
6673        placement: vec![
6674            PlacementModifier::Count {
6675                count: IntProvider::Constant(10i32),
6676            },
6677            PlacementModifier::InSquare,
6678            PlacementModifier::HeightRange {
6679                height: HeightProvider::Uniform {
6680                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
6681                    max_inclusive: VerticalAnchor::BelowTop(0i32),
6682                },
6683            },
6684            PlacementModifier::Biome,
6685        ],
6686    },
6687    id: OnceLock::new(),
6688});
6689pub static UNDERWATER_MAGMA: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6690    key: Identifier::vanilla_static("underwater_magma"),
6691    data: PlacedFeatureData {
6692        feature: ConfiguredFeatureRef::Reference(
6693            &crate::vanilla_configured_features::UNDERWATER_MAGMA,
6694        ),
6695        placement: vec![
6696            PlacementModifier::Count {
6697                count: IntProvider::Uniform {
6698                    min_inclusive: 44i32,
6699                    max_inclusive: 52i32,
6700                },
6701            },
6702            PlacementModifier::InSquare,
6703            PlacementModifier::HeightRange {
6704                height: HeightProvider::Uniform {
6705                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
6706                    max_inclusive: VerticalAnchor::Absolute(256i32),
6707                },
6708            },
6709            PlacementModifier::SurfaceRelativeThresholdFilter {
6710                heightmap: FeatureHeightmap::OceanFloorWg,
6711                min_inclusive: None,
6712                max_inclusive: Some(-2i32),
6713            },
6714            PlacementModifier::Biome,
6715        ],
6716    },
6717    id: OnceLock::new(),
6718});
6719pub static VINES: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6720    key: Identifier::vanilla_static("vines"),
6721    data: PlacedFeatureData {
6722        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::VINES),
6723        placement: vec![
6724            PlacementModifier::Count {
6725                count: IntProvider::Constant(127i32),
6726            },
6727            PlacementModifier::InSquare,
6728            PlacementModifier::HeightRange {
6729                height: HeightProvider::Uniform {
6730                    min_inclusive: VerticalAnchor::Absolute(64i32),
6731                    max_inclusive: VerticalAnchor::Absolute(100i32),
6732                },
6733            },
6734            PlacementModifier::Biome,
6735        ],
6736    },
6737    id: OnceLock::new(),
6738});
6739pub static VOID_START_PLATFORM: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6740    key: Identifier::vanilla_static("void_start_platform"),
6741    data: PlacedFeatureData {
6742        feature: ConfiguredFeatureRef::Reference(
6743            &crate::vanilla_configured_features::VOID_START_PLATFORM,
6744        ),
6745        placement: vec![PlacementModifier::Biome],
6746    },
6747    id: OnceLock::new(),
6748});
6749pub static WARM_OCEAN_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6750    key: Identifier::vanilla_static("warm_ocean_vegetation"),
6751    data: PlacedFeatureData {
6752        feature: ConfiguredFeatureRef::Reference(
6753            &crate::vanilla_configured_features::WARM_OCEAN_VEGETATION,
6754        ),
6755        placement: vec![
6756            PlacementModifier::NoiseBasedCount {
6757                noise_to_count_ratio: 20i32,
6758                noise_factor: 400f64,
6759                noise_offset: 0f64,
6760            },
6761            PlacementModifier::InSquare,
6762            PlacementModifier::Heightmap {
6763                heightmap: FeatureHeightmap::OceanFloorWg,
6764            },
6765            PlacementModifier::Biome,
6766        ],
6767    },
6768    id: OnceLock::new(),
6769});
6770pub static WARPED_FOREST_VEGETATION: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6771    key: Identifier::vanilla_static("warped_forest_vegetation"),
6772    data: PlacedFeatureData {
6773        feature: ConfiguredFeatureRef::Reference(
6774            &crate::vanilla_configured_features::WARPED_FOREST_VEGETATION,
6775        ),
6776        placement: vec![
6777            PlacementModifier::CountOnEveryLayer {
6778                count: IntProvider::Constant(5i32),
6779            },
6780            PlacementModifier::Biome,
6781        ],
6782    },
6783    id: OnceLock::new(),
6784});
6785pub static WARPED_FUNGI: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6786    key: Identifier::vanilla_static("warped_fungi"),
6787    data: PlacedFeatureData {
6788        feature: ConfiguredFeatureRef::Reference(
6789            &crate::vanilla_configured_features::WARPED_FUNGUS,
6790        ),
6791        placement: vec![
6792            PlacementModifier::CountOnEveryLayer {
6793                count: IntProvider::Constant(8i32),
6794            },
6795            PlacementModifier::Biome,
6796        ],
6797    },
6798    id: OnceLock::new(),
6799});
6800pub static WEEPING_VINES: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6801    key: Identifier::vanilla_static("weeping_vines"),
6802    data: PlacedFeatureData {
6803        feature: ConfiguredFeatureRef::Reference(
6804            &crate::vanilla_configured_features::WEEPING_VINES,
6805        ),
6806        placement: vec![
6807            PlacementModifier::Count {
6808                count: IntProvider::Constant(10i32),
6809            },
6810            PlacementModifier::InSquare,
6811            PlacementModifier::HeightRange {
6812                height: HeightProvider::Uniform {
6813                    min_inclusive: VerticalAnchor::AboveBottom(0i32),
6814                    max_inclusive: VerticalAnchor::BelowTop(0i32),
6815                },
6816            },
6817            PlacementModifier::Biome,
6818        ],
6819    },
6820    id: OnceLock::new(),
6821});
6822pub static WILDFLOWERS_BIRCH_FOREST: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6823    key: Identifier::vanilla_static("wildflowers_birch_forest"),
6824    data: PlacedFeatureData {
6825        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::WILDFLOWER),
6826        placement: vec![
6827            PlacementModifier::Count {
6828                count: IntProvider::Constant(3i32),
6829            },
6830            PlacementModifier::RarityFilter { chance: 2i32 },
6831            PlacementModifier::InSquare,
6832            PlacementModifier::Heightmap {
6833                heightmap: FeatureHeightmap::MotionBlocking,
6834            },
6835            PlacementModifier::Biome,
6836            PlacementModifier::Count {
6837                count: IntProvider::Constant(64i32),
6838            },
6839            PlacementModifier::RandomOffset {
6840                xz_spread: IntProvider::Trapezoid {
6841                    min: -6i32,
6842                    max: 6i32,
6843                    plateau: 0i32,
6844                },
6845                y_spread: IntProvider::Trapezoid {
6846                    min: -2i32,
6847                    max: 2i32,
6848                    plateau: 0i32,
6849                },
6850            },
6851            PlacementModifier::BlockPredicateFilter {
6852                predicate: BlockPredicate::MatchingBlockTag {
6853                    tag: Identifier::vanilla_static("air"),
6854                    offset: [0i32, 0i32, 0i32],
6855                },
6856            },
6857        ],
6858    },
6859    id: OnceLock::new(),
6860});
6861pub static WILDFLOWERS_MEADOW: LazyLock<PlacedFeature> = LazyLock::new(|| PlacedFeature {
6862    key: Identifier::vanilla_static("wildflowers_meadow"),
6863    data: PlacedFeatureData {
6864        feature: ConfiguredFeatureRef::Reference(&crate::vanilla_configured_features::WILDFLOWER),
6865        placement: vec![
6866            PlacementModifier::NoiseThresholdCount {
6867                noise_level: -0.8f64,
6868                below_noise: 5i32,
6869                above_noise: 10i32,
6870            },
6871            PlacementModifier::InSquare,
6872            PlacementModifier::Heightmap {
6873                heightmap: FeatureHeightmap::MotionBlocking,
6874            },
6875            PlacementModifier::Biome,
6876            PlacementModifier::Count {
6877                count: IntProvider::Constant(8i32),
6878            },
6879            PlacementModifier::RandomOffset {
6880                xz_spread: IntProvider::Trapezoid {
6881                    min: -6i32,
6882                    max: 6i32,
6883                    plateau: 0i32,
6884                },
6885                y_spread: IntProvider::Trapezoid {
6886                    min: -2i32,
6887                    max: 2i32,
6888                    plateau: 0i32,
6889                },
6890            },
6891            PlacementModifier::BlockPredicateFilter {
6892                predicate: BlockPredicate::MatchingBlockTag {
6893                    tag: Identifier::vanilla_static("air"),
6894                    offset: [0i32, 0i32, 0i32],
6895                },
6896            },
6897        ],
6898    },
6899    id: OnceLock::new(),
6900});
6901pub fn register_placed_features(registry: &mut PlacedFeatureRegistry) {
6902    registry.register(&ACACIA);
6903    registry.register(&ACACIA_CHECKED);
6904    registry.register(&AMETHYST_GEODE);
6905    registry.register(&BAMBOO);
6906    registry.register(&BAMBOO_LIGHT);
6907    registry.register(&BAMBOO_VEGETATION);
6908    registry.register(&BASALT_BLOBS);
6909    registry.register(&BASALT_PILLAR);
6910    registry.register(&BIRCH_BEES_0002);
6911    registry.register(&BIRCH_BEES_0002_LEAF_LITTER);
6912    registry.register(&BIRCH_BEES_002);
6913    registry.register(&BIRCH_CHECKED);
6914    registry.register(&BIRCH_LEAF_LITTER);
6915    registry.register(&BIRCH_TALL);
6916    registry.register(&BLACKSTONE_BLOBS);
6917    registry.register(&BLUE_ICE);
6918    registry.register(&BROWN_MUSHROOM_NETHER);
6919    registry.register(&BROWN_MUSHROOM_NORMAL);
6920    registry.register(&BROWN_MUSHROOM_OLD_GROWTH);
6921    registry.register(&BROWN_MUSHROOM_SWAMP);
6922    registry.register(&BROWN_MUSHROOM_TAIGA);
6923    registry.register(&CAVE_VINES);
6924    registry.register(&CHERRY_BEES_005);
6925    registry.register(&CHERRY_CHECKED);
6926    registry.register(&CHORUS_PLANT);
6927    registry.register(&CLASSIC_VINES_CAVE_FEATURE);
6928    registry.register(&CRIMSON_FOREST_VEGETATION);
6929    registry.register(&CRIMSON_FUNGI);
6930    registry.register(&DARK_FOREST_VEGETATION);
6931    registry.register(&DARK_OAK_CHECKED);
6932    registry.register(&DARK_OAK_LEAF_LITTER);
6933    registry.register(&DELTA);
6934    registry.register(&DESERT_WELL);
6935    registry.register(&DISK_CLAY);
6936    registry.register(&DISK_GRASS);
6937    registry.register(&DISK_GRAVEL);
6938    registry.register(&DISK_SAND);
6939    registry.register(&DRIPSTONE_CLUSTER);
6940    registry.register(&END_GATEWAY_RETURN);
6941    registry.register(&END_ISLAND_DECORATED);
6942    registry.register(&END_PLATFORM);
6943    registry.register(&END_SPIKE);
6944    registry.register(&FALLEN_BIRCH_TREE);
6945    registry.register(&FALLEN_JUNGLE_TREE);
6946    registry.register(&FALLEN_OAK_TREE);
6947    registry.register(&FALLEN_SPRUCE_TREE);
6948    registry.register(&FALLEN_SUPER_BIRCH_TREE);
6949    registry.register(&FANCY_OAK_BEES);
6950    registry.register(&FANCY_OAK_BEES_0002_LEAF_LITTER);
6951    registry.register(&FANCY_OAK_BEES_002);
6952    registry.register(&FANCY_OAK_CHECKED);
6953    registry.register(&FANCY_OAK_LEAF_LITTER);
6954    registry.register(&FLOWER_CHERRY);
6955    registry.register(&FLOWER_DEFAULT);
6956    registry.register(&FLOWER_FLOWER_FOREST);
6957    registry.register(&FLOWER_FOREST_FLOWERS);
6958    registry.register(&FLOWER_MEADOW);
6959    registry.register(&FLOWER_PALE_GARDEN);
6960    registry.register(&FLOWER_PLAIN);
6961    registry.register(&FLOWER_PLAINS);
6962    registry.register(&FLOWER_SWAMP);
6963    registry.register(&FLOWER_WARM);
6964    registry.register(&FOREST_FLOWERS);
6965    registry.register(&FOREST_ROCK);
6966    registry.register(&FOSSIL_LOWER);
6967    registry.register(&FOSSIL_UPPER);
6968    registry.register(&FREEZE_TOP_LAYER);
6969    registry.register(&GLOW_LICHEN);
6970    registry.register(&GLOWSTONE);
6971    registry.register(&GLOWSTONE_EXTRA);
6972    registry.register(&GRASS_BONEMEAL);
6973    registry.register(&ICE_PATCH);
6974    registry.register(&ICE_SPIKE);
6975    registry.register(&ICEBERG_BLUE);
6976    registry.register(&ICEBERG_PACKED);
6977    registry.register(&JUNGLE_BUSH);
6978    registry.register(&JUNGLE_TREE);
6979    registry.register(&KELP_COLD);
6980    registry.register(&KELP_WARM);
6981    registry.register(&LAKE_LAVA_SURFACE);
6982    registry.register(&LAKE_LAVA_UNDERGROUND);
6983    registry.register(&LARGE_BASALT_COLUMNS);
6984    registry.register(&LARGE_DRIPSTONE);
6985    registry.register(&LUSH_CAVES_CEILING_VEGETATION);
6986    registry.register(&LUSH_CAVES_CLAY);
6987    registry.register(&LUSH_CAVES_VEGETATION);
6988    registry.register(&MANGROVE_CHECKED);
6989    registry.register(&MEGA_JUNGLE_TREE_CHECKED);
6990    registry.register(&MEGA_PINE_CHECKED);
6991    registry.register(&MEGA_SPRUCE_CHECKED);
6992    registry.register(&MONSTER_ROOM);
6993    registry.register(&MONSTER_ROOM_DEEP);
6994    registry.register(&MUSHROOM_ISLAND_VEGETATION);
6995    registry.register(&NETHER_SPROUTS);
6996    registry.register(&OAK);
6997    registry.register(&OAK_BEES_0002_LEAF_LITTER);
6998    registry.register(&OAK_BEES_002);
6999    registry.register(&OAK_CHECKED);
7000    registry.register(&OAK_LEAF_LITTER);
7001    registry.register(&ORE_ANCIENT_DEBRIS_LARGE);
7002    registry.register(&ORE_ANDESITE_LOWER);
7003    registry.register(&ORE_ANDESITE_UPPER);
7004    registry.register(&ORE_BLACKSTONE);
7005    registry.register(&ORE_CLAY);
7006    registry.register(&ORE_COAL_LOWER);
7007    registry.register(&ORE_COAL_UPPER);
7008    registry.register(&ORE_COPPER);
7009    registry.register(&ORE_COPPER_LARGE);
7010    registry.register(&ORE_DEBRIS_SMALL);
7011    registry.register(&ORE_DIAMOND);
7012    registry.register(&ORE_DIAMOND_BURIED);
7013    registry.register(&ORE_DIAMOND_LARGE);
7014    registry.register(&ORE_DIAMOND_MEDIUM);
7015    registry.register(&ORE_DIORITE_LOWER);
7016    registry.register(&ORE_DIORITE_UPPER);
7017    registry.register(&ORE_DIRT);
7018    registry.register(&ORE_EMERALD);
7019    registry.register(&ORE_GOLD);
7020    registry.register(&ORE_GOLD_DELTAS);
7021    registry.register(&ORE_GOLD_EXTRA);
7022    registry.register(&ORE_GOLD_LOWER);
7023    registry.register(&ORE_GOLD_NETHER);
7024    registry.register(&ORE_GRANITE_LOWER);
7025    registry.register(&ORE_GRANITE_UPPER);
7026    registry.register(&ORE_GRAVEL);
7027    registry.register(&ORE_GRAVEL_NETHER);
7028    registry.register(&ORE_INFESTED);
7029    registry.register(&ORE_IRON_MIDDLE);
7030    registry.register(&ORE_IRON_SMALL);
7031    registry.register(&ORE_IRON_UPPER);
7032    registry.register(&ORE_LAPIS);
7033    registry.register(&ORE_LAPIS_BURIED);
7034    registry.register(&ORE_MAGMA);
7035    registry.register(&ORE_QUARTZ_DELTAS);
7036    registry.register(&ORE_QUARTZ_NETHER);
7037    registry.register(&ORE_REDSTONE);
7038    registry.register(&ORE_REDSTONE_LOWER);
7039    registry.register(&ORE_SOUL_SAND);
7040    registry.register(&ORE_TUFF);
7041    registry.register(&PALE_GARDEN_FLOWERS);
7042    registry.register(&PALE_GARDEN_VEGETATION);
7043    registry.register(&PALE_MOSS_PATCH);
7044    registry.register(&PALE_OAK_CHECKED);
7045    registry.register(&PALE_OAK_CREAKING_CHECKED);
7046    registry.register(&PATCH_BERRY_BUSH);
7047    registry.register(&PATCH_BERRY_COMMON);
7048    registry.register(&PATCH_BERRY_RARE);
7049    registry.register(&PATCH_BUSH);
7050    registry.register(&PATCH_CACTUS);
7051    registry.register(&PATCH_CACTUS_DECORATED);
7052    registry.register(&PATCH_CACTUS_DESERT);
7053    registry.register(&PATCH_CRIMSON_ROOTS);
7054    registry.register(&PATCH_DEAD_BUSH);
7055    registry.register(&PATCH_DEAD_BUSH_2);
7056    registry.register(&PATCH_DEAD_BUSH_BADLANDS);
7057    registry.register(&PATCH_DRY_GRASS_BADLANDS);
7058    registry.register(&PATCH_DRY_GRASS_DESERT);
7059    registry.register(&PATCH_FIRE);
7060    registry.register(&PATCH_FIREFLY_BUSH_NEAR_WATER);
7061    registry.register(&PATCH_FIREFLY_BUSH_NEAR_WATER_SWAMP);
7062    registry.register(&PATCH_FIREFLY_BUSH_SWAMP);
7063    registry.register(&PATCH_GRASS_BADLANDS);
7064    registry.register(&PATCH_GRASS_FOREST);
7065    registry.register(&PATCH_GRASS_JUNGLE);
7066    registry.register(&PATCH_GRASS_MEADOW);
7067    registry.register(&PATCH_GRASS_NORMAL);
7068    registry.register(&PATCH_GRASS_PLAIN);
7069    registry.register(&PATCH_GRASS_SAVANNA);
7070    registry.register(&PATCH_GRASS_TAIGA);
7071    registry.register(&PATCH_GRASS_TAIGA_2);
7072    registry.register(&PATCH_LARGE_FERN);
7073    registry.register(&PATCH_LEAF_LITTER);
7074    registry.register(&PATCH_MELON);
7075    registry.register(&PATCH_MELON_SPARSE);
7076    registry.register(&PATCH_PUMPKIN);
7077    registry.register(&PATCH_SOUL_FIRE);
7078    registry.register(&PATCH_SUGAR_CANE);
7079    registry.register(&PATCH_SUGAR_CANE_BADLANDS);
7080    registry.register(&PATCH_SUGAR_CANE_DESERT);
7081    registry.register(&PATCH_SUGAR_CANE_SWAMP);
7082    registry.register(&PATCH_SUNFLOWER);
7083    registry.register(&PATCH_TAIGA_GRASS);
7084    registry.register(&PATCH_TALL_GRASS);
7085    registry.register(&PATCH_TALL_GRASS_2);
7086    registry.register(&PATCH_WATERLILY);
7087    registry.register(&PILE_HAY);
7088    registry.register(&PILE_ICE);
7089    registry.register(&PILE_MELON);
7090    registry.register(&PILE_PUMPKIN);
7091    registry.register(&PILE_SNOW);
7092    registry.register(&PINE);
7093    registry.register(&PINE_CHECKED);
7094    registry.register(&PINE_ON_SNOW);
7095    registry.register(&POINTED_DRIPSTONE);
7096    registry.register(&RED_MUSHROOM_NETHER);
7097    registry.register(&RED_MUSHROOM_NORMAL);
7098    registry.register(&RED_MUSHROOM_OLD_GROWTH);
7099    registry.register(&RED_MUSHROOM_SWAMP);
7100    registry.register(&RED_MUSHROOM_TAIGA);
7101    registry.register(&ROOTED_AZALEA_TREE);
7102    registry.register(&SCULK_PATCH_ANCIENT_CITY);
7103    registry.register(&SCULK_PATCH_DEEP_DARK);
7104    registry.register(&SCULK_VEIN);
7105    registry.register(&SEA_PICKLE);
7106    registry.register(&SEAGRASS_COLD);
7107    registry.register(&SEAGRASS_DEEP);
7108    registry.register(&SEAGRASS_DEEP_COLD);
7109    registry.register(&SEAGRASS_DEEP_WARM);
7110    registry.register(&SEAGRASS_NORMAL);
7111    registry.register(&SEAGRASS_RIVER);
7112    registry.register(&SEAGRASS_SWAMP);
7113    registry.register(&SEAGRASS_WARM);
7114    registry.register(&SMALL_BASALT_COLUMNS);
7115    registry.register(&SPORE_BLOSSOM);
7116    registry.register(&SPRING_CLOSED);
7117    registry.register(&SPRING_CLOSED_DOUBLE);
7118    registry.register(&SPRING_DELTA);
7119    registry.register(&SPRING_LAVA);
7120    registry.register(&SPRING_LAVA_FROZEN);
7121    registry.register(&SPRING_OPEN);
7122    registry.register(&SPRING_WATER);
7123    registry.register(&SPRUCE);
7124    registry.register(&SPRUCE_CHECKED);
7125    registry.register(&SPRUCE_ON_SNOW);
7126    registry.register(&SUPER_BIRCH_BEES);
7127    registry.register(&SUPER_BIRCH_BEES_0002);
7128    registry.register(&TALL_MANGROVE_CHECKED);
7129    registry.register(&TREES_BADLANDS);
7130    registry.register(&TREES_BIRCH);
7131    registry.register(&TREES_BIRCH_AND_OAK_LEAF_LITTER);
7132    registry.register(&TREES_CHERRY);
7133    registry.register(&TREES_FLOWER_FOREST);
7134    registry.register(&TREES_GROVE);
7135    registry.register(&TREES_JUNGLE);
7136    registry.register(&TREES_MANGROVE);
7137    registry.register(&TREES_MEADOW);
7138    registry.register(&TREES_OLD_GROWTH_PINE_TAIGA);
7139    registry.register(&TREES_OLD_GROWTH_SPRUCE_TAIGA);
7140    registry.register(&TREES_PLAINS);
7141    registry.register(&TREES_SAVANNA);
7142    registry.register(&TREES_SNOWY);
7143    registry.register(&TREES_SPARSE_JUNGLE);
7144    registry.register(&TREES_SWAMP);
7145    registry.register(&TREES_TAIGA);
7146    registry.register(&TREES_WATER);
7147    registry.register(&TREES_WINDSWEPT_FOREST);
7148    registry.register(&TREES_WINDSWEPT_HILLS);
7149    registry.register(&TREES_WINDSWEPT_SAVANNA);
7150    registry.register(&TWISTING_VINES);
7151    registry.register(&UNDERWATER_MAGMA);
7152    registry.register(&VINES);
7153    registry.register(&VOID_START_PLATFORM);
7154    registry.register(&WARM_OCEAN_VEGETATION);
7155    registry.register(&WARPED_FOREST_VEGETATION);
7156    registry.register(&WARPED_FUNGI);
7157    registry.register(&WEEPING_VINES);
7158    registry.register(&WILDFLOWERS_BIRCH_FOREST);
7159    registry.register(&WILDFLOWERS_MEADOW);
7160}