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<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
9 key: Identifier::vanilla_static("acacia"),
10 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
11 trunk_provider: BlockStateProvider::Simple {
12 state: BlockStateData {
13 block: &vanilla_blocks::ACACIA_LOG,
14 properties: &[("axis", "y")],
15 },
16 },
17 below_trunk_provider: BlockStateProvider::RuleBased {
18 fallback: None,
19 rules: vec![RuleBasedStateProviderRule {
20 if_true: BlockPredicate::Not {
21 predicate: Box::new(BlockPredicate::MatchingBlockTag {
22 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
23 offset: [0i32, 0i32, 0i32],
24 }),
25 },
26 then: BlockStateProvider::Simple {
27 state: BlockStateData {
28 block: &vanilla_blocks::DIRT,
29 properties: &[],
30 },
31 },
32 }],
33 },
34 foliage_provider: BlockStateProvider::Simple {
35 state: BlockStateData {
36 block: &vanilla_blocks::ACACIA_LEAVES,
37 properties: &[
38 ("distance", "7"),
39 ("persistent", "false"),
40 ("waterlogged", "false"),
41 ],
42 },
43 },
44 trunk_placer: TrunkPlacer::Forking(TrunkPlacerBase {
45 base_height: 5i32,
46 height_rand_a: 2i32,
47 height_rand_b: 2i32,
48 }),
49 foliage_placer: FoliagePlacer::Acacia(FoliagePlacerBase {
50 radius: IntProvider::Constant(2i32),
51 offset: IntProvider::Constant(0i32),
52 }),
53 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
54 limit: 1i32,
55 lower_size: 0i32,
56 upper_size: 2i32,
57 min_clipped_height: None,
58 }),
59 decorators: vec![],
60 root_placer: None,
61 ignore_vines: true,
62 }),
63 id: OnceLock::new(),
64});
65pub static AMETHYST_GEODE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
66 key: Identifier::vanilla_static("amethyst_geode"),
67 kind: ConfiguredFeatureKind::Geode(GeodeConfiguration {
68 blocks: GeodeBlockSettings {
69 filling_provider: BlockStateProvider::Simple {
70 state: BlockStateData {
71 block: &vanilla_blocks::AIR,
72 properties: &[],
73 },
74 },
75 inner_layer_provider: BlockStateProvider::Simple {
76 state: BlockStateData {
77 block: &vanilla_blocks::AMETHYST_BLOCK,
78 properties: &[],
79 },
80 },
81 alternate_inner_layer_provider: BlockStateProvider::Simple {
82 state: BlockStateData {
83 block: &vanilla_blocks::BUDDING_AMETHYST,
84 properties: &[],
85 },
86 },
87 middle_layer_provider: BlockStateProvider::Simple {
88 state: BlockStateData {
89 block: &vanilla_blocks::CALCITE,
90 properties: &[],
91 },
92 },
93 outer_layer_provider: BlockStateProvider::Simple {
94 state: BlockStateData {
95 block: &vanilla_blocks::SMOOTH_BASALT,
96 properties: &[],
97 },
98 },
99 inner_placements: vec![
100 BlockStateData {
101 block: &vanilla_blocks::SMALL_AMETHYST_BUD,
102 properties: &[("facing", "up"), ("waterlogged", "false")],
103 },
104 BlockStateData {
105 block: &vanilla_blocks::MEDIUM_AMETHYST_BUD,
106 properties: &[("facing", "up"), ("waterlogged", "false")],
107 },
108 BlockStateData {
109 block: &vanilla_blocks::LARGE_AMETHYST_BUD,
110 properties: &[("facing", "up"), ("waterlogged", "false")],
111 },
112 BlockStateData {
113 block: &vanilla_blocks::AMETHYST_CLUSTER,
114 properties: &[("facing", "up"), ("waterlogged", "false")],
115 },
116 ],
117 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
118 invalid_blocks: Identifier::vanilla_static("geode_invalid_blocks"),
119 },
120 layers: GeodeLayerSettings {
121 filling: 1.7f64,
122 inner_layer: 2.2f64,
123 middle_layer: 3.2f64,
124 outer_layer: 4.2f64,
125 },
126 crack: GeodeCrackSettings {
127 generate_crack_chance: 0.95f64,
128 base_crack_size: 2f64,
129 crack_point_offset: 2i32,
130 },
131 use_potential_placements_chance: 0.35f64,
132 use_alternate_layer0_chance: 0.083f64,
133 placements_require_layer0_alternate: true,
134 outer_wall_distance: IntProvider::Uniform {
135 min_inclusive: 4i32,
136 max_inclusive: 6i32,
137 },
138 distribution_points: IntProvider::Uniform {
139 min_inclusive: 3i32,
140 max_inclusive: 4i32,
141 },
142 point_offset: IntProvider::Uniform {
143 min_inclusive: 1i32,
144 max_inclusive: 2i32,
145 },
146 min_gen_offset: -16i32,
147 max_gen_offset: 16i32,
148 invalid_blocks_threshold: 1i32,
149 noise_multiplier: 0.05f64,
150 }),
151 id: OnceLock::new(),
152});
153pub static AZALEA_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
154 key: Identifier::vanilla_static("azalea_tree"),
155 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
156 trunk_provider: BlockStateProvider::Simple {
157 state: BlockStateData {
158 block: &vanilla_blocks::OAK_LOG,
159 properties: &[("axis", "y")],
160 },
161 },
162 below_trunk_provider: BlockStateProvider::Simple {
163 state: BlockStateData {
164 block: &vanilla_blocks::ROOTED_DIRT,
165 properties: &[],
166 },
167 },
168 foliage_provider: BlockStateProvider::Weighted {
169 entries: vec![
170 WeightedBlockState {
171 data: BlockStateData {
172 block: &vanilla_blocks::AZALEA_LEAVES,
173 properties: &[
174 ("distance", "7"),
175 ("persistent", "false"),
176 ("waterlogged", "false"),
177 ],
178 },
179 weight: 3i32,
180 },
181 WeightedBlockState {
182 data: BlockStateData {
183 block: &vanilla_blocks::FLOWERING_AZALEA_LEAVES,
184 properties: &[
185 ("distance", "7"),
186 ("persistent", "false"),
187 ("waterlogged", "false"),
188 ],
189 },
190 weight: 1i32,
191 },
192 ],
193 },
194 trunk_placer: TrunkPlacer::Bending(BendingTrunkPlacer {
195 base_height: 4i32,
196 height_rand_a: 2i32,
197 height_rand_b: 0i32,
198 min_height_for_leaves: 3i32,
199 bend_length: IntProvider::Uniform {
200 min_inclusive: 1i32,
201 max_inclusive: 2i32,
202 },
203 }),
204 foliage_placer: FoliagePlacer::RandomSpread(RandomSpreadFoliagePlacer {
205 radius: IntProvider::Constant(3i32),
206 offset: IntProvider::Constant(0i32),
207 foliage_height: 2i32,
208 leaf_placement_attempts: 50i32,
209 }),
210 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
211 limit: 1i32,
212 lower_size: 0i32,
213 upper_size: 1i32,
214 min_clipped_height: None,
215 }),
216 decorators: vec![],
217 root_placer: None,
218 ignore_vines: false,
219 }),
220 id: OnceLock::new(),
221});
222pub static BAMBOO_NO_PODZOL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
223 key: Identifier::vanilla_static("bamboo_no_podzol"),
224 kind: ConfiguredFeatureKind::Bamboo(BambooConfiguration { probability: 0f32 }),
225 id: OnceLock::new(),
226});
227pub static BAMBOO_SOME_PODZOL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
228 key: Identifier::vanilla_static("bamboo_some_podzol"),
229 kind: ConfiguredFeatureKind::Bamboo(BambooConfiguration {
230 probability: 0.2f32,
231 }),
232 id: OnceLock::new(),
233});
234pub static BAMBOO_VEGETATION: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
235 key: Identifier::vanilla_static("bamboo_vegetation"),
236 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
237 features: vec![
238 WeightedPlacedFeature {
239 chance: 0.05f32,
240 feature: PlacedFeatureRef::Reference(
241 &crate::vanilla_placed_features::FANCY_OAK_CHECKED,
242 ),
243 },
244 WeightedPlacedFeature {
245 chance: 0.15f32,
246 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::JUNGLE_BUSH),
247 },
248 WeightedPlacedFeature {
249 chance: 0.7f32,
250 feature: PlacedFeatureRef::Reference(
251 &crate::vanilla_placed_features::MEGA_JUNGLE_TREE_CHECKED,
252 ),
253 },
254 ],
255 default: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
256 feature: ConfiguredFeatureRef::Reference(
257 &crate::vanilla_configured_features::GRASS_JUNGLE,
258 ),
259 placement: vec![
260 PlacementModifier::Count {
261 count: IntProvider::Constant(32i32),
262 },
263 PlacementModifier::RandomOffset {
264 xz_spread: IntProvider::Trapezoid {
265 min: -7i32,
266 max: 7i32,
267 plateau: 0i32,
268 },
269 y_spread: IntProvider::Trapezoid {
270 min: -3i32,
271 max: 3i32,
272 plateau: 0i32,
273 },
274 },
275 PlacementModifier::BlockPredicateFilter {
276 predicate: BlockPredicate::AllOf {
277 predicates: vec![
278 BlockPredicate::MatchingBlockTag {
279 tag: Identifier::vanilla_static("air"),
280 offset: [0i32, 0i32, 0i32],
281 },
282 BlockPredicate::Not {
283 predicate: Box::new(BlockPredicate::MatchingBlocks {
284 blocks: BlockRefList(vec![&vanilla_blocks::PODZOL]),
285 offset: [0i32, -1i32, 0i32],
286 }),
287 },
288 ],
289 },
290 },
291 ],
292 })),
293 }),
294 id: OnceLock::new(),
295});
296pub static BASALT_BLOBS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
297 key: Identifier::vanilla_static("basalt_blobs"),
298 kind: ConfiguredFeatureKind::NetherrackReplaceBlobs(NetherrackReplaceBlobsConfiguration {
299 target: BlockStateData {
300 block: &vanilla_blocks::NETHERRACK,
301 properties: &[],
302 },
303 state: BlockStateData {
304 block: &vanilla_blocks::BASALT,
305 properties: &[("axis", "y")],
306 },
307 radius: IntProvider::Uniform {
308 min_inclusive: 3i32,
309 max_inclusive: 7i32,
310 },
311 }),
312 id: OnceLock::new(),
313});
314pub static BASALT_PILLAR: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
315 key: Identifier::vanilla_static("basalt_pillar"),
316 kind: ConfiguredFeatureKind::BasaltPillar,
317 id: OnceLock::new(),
318});
319pub static BERRY_BUSH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
320 key: Identifier::vanilla_static("berry_bush"),
321 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
322 to_place: BlockStateProvider::Simple {
323 state: BlockStateData {
324 block: &vanilla_blocks::SWEET_BERRY_BUSH,
325 properties: &[("age", "3")],
326 },
327 },
328 schedule_tick: false,
329 }),
330 id: OnceLock::new(),
331});
332pub static BIRCH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
333 key: Identifier::vanilla_static("birch"),
334 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
335 trunk_provider: BlockStateProvider::Simple {
336 state: BlockStateData {
337 block: &vanilla_blocks::BIRCH_LOG,
338 properties: &[("axis", "y")],
339 },
340 },
341 below_trunk_provider: BlockStateProvider::RuleBased {
342 fallback: None,
343 rules: vec![RuleBasedStateProviderRule {
344 if_true: BlockPredicate::Not {
345 predicate: Box::new(BlockPredicate::MatchingBlockTag {
346 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
347 offset: [0i32, 0i32, 0i32],
348 }),
349 },
350 then: BlockStateProvider::Simple {
351 state: BlockStateData {
352 block: &vanilla_blocks::DIRT,
353 properties: &[],
354 },
355 },
356 }],
357 },
358 foliage_provider: BlockStateProvider::Simple {
359 state: BlockStateData {
360 block: &vanilla_blocks::BIRCH_LEAVES,
361 properties: &[
362 ("distance", "7"),
363 ("persistent", "false"),
364 ("waterlogged", "false"),
365 ],
366 },
367 },
368 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
369 base_height: 5i32,
370 height_rand_a: 2i32,
371 height_rand_b: 0i32,
372 }),
373 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
374 radius: IntProvider::Constant(2i32),
375 offset: IntProvider::Constant(0i32),
376 height: IntProvider::Constant(3i32),
377 }),
378 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
379 limit: 1i32,
380 lower_size: 0i32,
381 upper_size: 1i32,
382 min_clipped_height: None,
383 }),
384 decorators: vec![],
385 root_placer: None,
386 ignore_vines: true,
387 }),
388 id: OnceLock::new(),
389});
390pub static BIRCH_BEES_0002: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
391 key: Identifier::vanilla_static("birch_bees_0002"),
392 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
393 trunk_provider: BlockStateProvider::Simple {
394 state: BlockStateData {
395 block: &vanilla_blocks::BIRCH_LOG,
396 properties: &[("axis", "y")],
397 },
398 },
399 below_trunk_provider: BlockStateProvider::RuleBased {
400 fallback: None,
401 rules: vec![RuleBasedStateProviderRule {
402 if_true: BlockPredicate::Not {
403 predicate: Box::new(BlockPredicate::MatchingBlockTag {
404 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
405 offset: [0i32, 0i32, 0i32],
406 }),
407 },
408 then: BlockStateProvider::Simple {
409 state: BlockStateData {
410 block: &vanilla_blocks::DIRT,
411 properties: &[],
412 },
413 },
414 }],
415 },
416 foliage_provider: BlockStateProvider::Simple {
417 state: BlockStateData {
418 block: &vanilla_blocks::BIRCH_LEAVES,
419 properties: &[
420 ("distance", "7"),
421 ("persistent", "false"),
422 ("waterlogged", "false"),
423 ],
424 },
425 },
426 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
427 base_height: 5i32,
428 height_rand_a: 2i32,
429 height_rand_b: 0i32,
430 }),
431 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
432 radius: IntProvider::Constant(2i32),
433 offset: IntProvider::Constant(0i32),
434 height: IntProvider::Constant(3i32),
435 }),
436 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
437 limit: 1i32,
438 lower_size: 0i32,
439 upper_size: 1i32,
440 min_clipped_height: None,
441 }),
442 decorators: vec![TreeDecorator::Beehive {
443 probability: 0.002f32,
444 }],
445 root_placer: None,
446 ignore_vines: true,
447 }),
448 id: OnceLock::new(),
449});
450pub static BIRCH_BEES_0002_LEAF_LITTER: LazyLock<ConfiguredFeature> =
451 LazyLock::new(|| ConfiguredFeature {
452 key: Identifier::vanilla_static("birch_bees_0002_leaf_litter"),
453 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
454 trunk_provider: BlockStateProvider::Simple {
455 state: BlockStateData {
456 block: &vanilla_blocks::BIRCH_LOG,
457 properties: &[("axis", "y")],
458 },
459 },
460 below_trunk_provider: BlockStateProvider::RuleBased {
461 fallback: None,
462 rules: vec![RuleBasedStateProviderRule {
463 if_true: BlockPredicate::Not {
464 predicate: Box::new(BlockPredicate::MatchingBlockTag {
465 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
466 offset: [0i32, 0i32, 0i32],
467 }),
468 },
469 then: BlockStateProvider::Simple {
470 state: BlockStateData {
471 block: &vanilla_blocks::DIRT,
472 properties: &[],
473 },
474 },
475 }],
476 },
477 foliage_provider: BlockStateProvider::Simple {
478 state: BlockStateData {
479 block: &vanilla_blocks::BIRCH_LEAVES,
480 properties: &[
481 ("distance", "7"),
482 ("persistent", "false"),
483 ("waterlogged", "false"),
484 ],
485 },
486 },
487 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
488 base_height: 5i32,
489 height_rand_a: 2i32,
490 height_rand_b: 0i32,
491 }),
492 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
493 radius: IntProvider::Constant(2i32),
494 offset: IntProvider::Constant(0i32),
495 height: IntProvider::Constant(3i32),
496 }),
497 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
498 limit: 1i32,
499 lower_size: 0i32,
500 upper_size: 1i32,
501 min_clipped_height: None,
502 }),
503 decorators: vec![
504 TreeDecorator::Beehive {
505 probability: 0.002f32,
506 },
507 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
508 block_state_provider: BlockStateProvider::Weighted {
509 entries: vec![
510 WeightedBlockState {
511 data: BlockStateData {
512 block: &vanilla_blocks::LEAF_LITTER,
513 properties: &[("facing", "north"), ("segment_amount", "1")],
514 },
515 weight: 1i32,
516 },
517 WeightedBlockState {
518 data: BlockStateData {
519 block: &vanilla_blocks::LEAF_LITTER,
520 properties: &[("facing", "east"), ("segment_amount", "1")],
521 },
522 weight: 1i32,
523 },
524 WeightedBlockState {
525 data: BlockStateData {
526 block: &vanilla_blocks::LEAF_LITTER,
527 properties: &[("facing", "south"), ("segment_amount", "1")],
528 },
529 weight: 1i32,
530 },
531 WeightedBlockState {
532 data: BlockStateData {
533 block: &vanilla_blocks::LEAF_LITTER,
534 properties: &[("facing", "west"), ("segment_amount", "1")],
535 },
536 weight: 1i32,
537 },
538 WeightedBlockState {
539 data: BlockStateData {
540 block: &vanilla_blocks::LEAF_LITTER,
541 properties: &[("facing", "north"), ("segment_amount", "2")],
542 },
543 weight: 1i32,
544 },
545 WeightedBlockState {
546 data: BlockStateData {
547 block: &vanilla_blocks::LEAF_LITTER,
548 properties: &[("facing", "east"), ("segment_amount", "2")],
549 },
550 weight: 1i32,
551 },
552 WeightedBlockState {
553 data: BlockStateData {
554 block: &vanilla_blocks::LEAF_LITTER,
555 properties: &[("facing", "south"), ("segment_amount", "2")],
556 },
557 weight: 1i32,
558 },
559 WeightedBlockState {
560 data: BlockStateData {
561 block: &vanilla_blocks::LEAF_LITTER,
562 properties: &[("facing", "west"), ("segment_amount", "2")],
563 },
564 weight: 1i32,
565 },
566 WeightedBlockState {
567 data: BlockStateData {
568 block: &vanilla_blocks::LEAF_LITTER,
569 properties: &[("facing", "north"), ("segment_amount", "3")],
570 },
571 weight: 1i32,
572 },
573 WeightedBlockState {
574 data: BlockStateData {
575 block: &vanilla_blocks::LEAF_LITTER,
576 properties: &[("facing", "east"), ("segment_amount", "3")],
577 },
578 weight: 1i32,
579 },
580 WeightedBlockState {
581 data: BlockStateData {
582 block: &vanilla_blocks::LEAF_LITTER,
583 properties: &[("facing", "south"), ("segment_amount", "3")],
584 },
585 weight: 1i32,
586 },
587 WeightedBlockState {
588 data: BlockStateData {
589 block: &vanilla_blocks::LEAF_LITTER,
590 properties: &[("facing", "west"), ("segment_amount", "3")],
591 },
592 weight: 1i32,
593 },
594 ],
595 },
596 tries: 96i32,
597 radius: 4i32,
598 height: 2i32,
599 }),
600 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
601 block_state_provider: BlockStateProvider::Weighted {
602 entries: vec![
603 WeightedBlockState {
604 data: BlockStateData {
605 block: &vanilla_blocks::LEAF_LITTER,
606 properties: &[("facing", "north"), ("segment_amount", "1")],
607 },
608 weight: 1i32,
609 },
610 WeightedBlockState {
611 data: BlockStateData {
612 block: &vanilla_blocks::LEAF_LITTER,
613 properties: &[("facing", "east"), ("segment_amount", "1")],
614 },
615 weight: 1i32,
616 },
617 WeightedBlockState {
618 data: BlockStateData {
619 block: &vanilla_blocks::LEAF_LITTER,
620 properties: &[("facing", "south"), ("segment_amount", "1")],
621 },
622 weight: 1i32,
623 },
624 WeightedBlockState {
625 data: BlockStateData {
626 block: &vanilla_blocks::LEAF_LITTER,
627 properties: &[("facing", "west"), ("segment_amount", "1")],
628 },
629 weight: 1i32,
630 },
631 WeightedBlockState {
632 data: BlockStateData {
633 block: &vanilla_blocks::LEAF_LITTER,
634 properties: &[("facing", "north"), ("segment_amount", "2")],
635 },
636 weight: 1i32,
637 },
638 WeightedBlockState {
639 data: BlockStateData {
640 block: &vanilla_blocks::LEAF_LITTER,
641 properties: &[("facing", "east"), ("segment_amount", "2")],
642 },
643 weight: 1i32,
644 },
645 WeightedBlockState {
646 data: BlockStateData {
647 block: &vanilla_blocks::LEAF_LITTER,
648 properties: &[("facing", "south"), ("segment_amount", "2")],
649 },
650 weight: 1i32,
651 },
652 WeightedBlockState {
653 data: BlockStateData {
654 block: &vanilla_blocks::LEAF_LITTER,
655 properties: &[("facing", "west"), ("segment_amount", "2")],
656 },
657 weight: 1i32,
658 },
659 WeightedBlockState {
660 data: BlockStateData {
661 block: &vanilla_blocks::LEAF_LITTER,
662 properties: &[("facing", "north"), ("segment_amount", "3")],
663 },
664 weight: 1i32,
665 },
666 WeightedBlockState {
667 data: BlockStateData {
668 block: &vanilla_blocks::LEAF_LITTER,
669 properties: &[("facing", "east"), ("segment_amount", "3")],
670 },
671 weight: 1i32,
672 },
673 WeightedBlockState {
674 data: BlockStateData {
675 block: &vanilla_blocks::LEAF_LITTER,
676 properties: &[("facing", "south"), ("segment_amount", "3")],
677 },
678 weight: 1i32,
679 },
680 WeightedBlockState {
681 data: BlockStateData {
682 block: &vanilla_blocks::LEAF_LITTER,
683 properties: &[("facing", "west"), ("segment_amount", "3")],
684 },
685 weight: 1i32,
686 },
687 WeightedBlockState {
688 data: BlockStateData {
689 block: &vanilla_blocks::LEAF_LITTER,
690 properties: &[("facing", "north"), ("segment_amount", "4")],
691 },
692 weight: 1i32,
693 },
694 WeightedBlockState {
695 data: BlockStateData {
696 block: &vanilla_blocks::LEAF_LITTER,
697 properties: &[("facing", "east"), ("segment_amount", "4")],
698 },
699 weight: 1i32,
700 },
701 WeightedBlockState {
702 data: BlockStateData {
703 block: &vanilla_blocks::LEAF_LITTER,
704 properties: &[("facing", "south"), ("segment_amount", "4")],
705 },
706 weight: 1i32,
707 },
708 WeightedBlockState {
709 data: BlockStateData {
710 block: &vanilla_blocks::LEAF_LITTER,
711 properties: &[("facing", "west"), ("segment_amount", "4")],
712 },
713 weight: 1i32,
714 },
715 ],
716 },
717 tries: 150i32,
718 radius: 2i32,
719 height: 2i32,
720 }),
721 ],
722 root_placer: None,
723 ignore_vines: true,
724 }),
725 id: OnceLock::new(),
726 });
727pub static BIRCH_BEES_002: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
728 key: Identifier::vanilla_static("birch_bees_002"),
729 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
730 trunk_provider: BlockStateProvider::Simple {
731 state: BlockStateData {
732 block: &vanilla_blocks::BIRCH_LOG,
733 properties: &[("axis", "y")],
734 },
735 },
736 below_trunk_provider: BlockStateProvider::RuleBased {
737 fallback: None,
738 rules: vec![RuleBasedStateProviderRule {
739 if_true: BlockPredicate::Not {
740 predicate: Box::new(BlockPredicate::MatchingBlockTag {
741 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
742 offset: [0i32, 0i32, 0i32],
743 }),
744 },
745 then: BlockStateProvider::Simple {
746 state: BlockStateData {
747 block: &vanilla_blocks::DIRT,
748 properties: &[],
749 },
750 },
751 }],
752 },
753 foliage_provider: BlockStateProvider::Simple {
754 state: BlockStateData {
755 block: &vanilla_blocks::BIRCH_LEAVES,
756 properties: &[
757 ("distance", "7"),
758 ("persistent", "false"),
759 ("waterlogged", "false"),
760 ],
761 },
762 },
763 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
764 base_height: 5i32,
765 height_rand_a: 2i32,
766 height_rand_b: 0i32,
767 }),
768 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
769 radius: IntProvider::Constant(2i32),
770 offset: IntProvider::Constant(0i32),
771 height: IntProvider::Constant(3i32),
772 }),
773 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
774 limit: 1i32,
775 lower_size: 0i32,
776 upper_size: 1i32,
777 min_clipped_height: None,
778 }),
779 decorators: vec![TreeDecorator::Beehive {
780 probability: 0.02f32,
781 }],
782 root_placer: None,
783 ignore_vines: true,
784 }),
785 id: OnceLock::new(),
786});
787pub static BIRCH_BEES_005: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
788 key: Identifier::vanilla_static("birch_bees_005"),
789 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
790 trunk_provider: BlockStateProvider::Simple {
791 state: BlockStateData {
792 block: &vanilla_blocks::BIRCH_LOG,
793 properties: &[("axis", "y")],
794 },
795 },
796 below_trunk_provider: BlockStateProvider::RuleBased {
797 fallback: None,
798 rules: vec![RuleBasedStateProviderRule {
799 if_true: BlockPredicate::Not {
800 predicate: Box::new(BlockPredicate::MatchingBlockTag {
801 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
802 offset: [0i32, 0i32, 0i32],
803 }),
804 },
805 then: BlockStateProvider::Simple {
806 state: BlockStateData {
807 block: &vanilla_blocks::DIRT,
808 properties: &[],
809 },
810 },
811 }],
812 },
813 foliage_provider: BlockStateProvider::Simple {
814 state: BlockStateData {
815 block: &vanilla_blocks::BIRCH_LEAVES,
816 properties: &[
817 ("distance", "7"),
818 ("persistent", "false"),
819 ("waterlogged", "false"),
820 ],
821 },
822 },
823 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
824 base_height: 5i32,
825 height_rand_a: 2i32,
826 height_rand_b: 0i32,
827 }),
828 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
829 radius: IntProvider::Constant(2i32),
830 offset: IntProvider::Constant(0i32),
831 height: IntProvider::Constant(3i32),
832 }),
833 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
834 limit: 1i32,
835 lower_size: 0i32,
836 upper_size: 1i32,
837 min_clipped_height: None,
838 }),
839 decorators: vec![TreeDecorator::Beehive {
840 probability: 0.05f32,
841 }],
842 root_placer: None,
843 ignore_vines: true,
844 }),
845 id: OnceLock::new(),
846});
847pub static BIRCH_LEAF_LITTER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
848 key: Identifier::vanilla_static("birch_leaf_litter"),
849 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
850 trunk_provider: BlockStateProvider::Simple {
851 state: BlockStateData {
852 block: &vanilla_blocks::BIRCH_LOG,
853 properties: &[("axis", "y")],
854 },
855 },
856 below_trunk_provider: BlockStateProvider::RuleBased {
857 fallback: None,
858 rules: vec![RuleBasedStateProviderRule {
859 if_true: BlockPredicate::Not {
860 predicate: Box::new(BlockPredicate::MatchingBlockTag {
861 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
862 offset: [0i32, 0i32, 0i32],
863 }),
864 },
865 then: BlockStateProvider::Simple {
866 state: BlockStateData {
867 block: &vanilla_blocks::DIRT,
868 properties: &[],
869 },
870 },
871 }],
872 },
873 foliage_provider: BlockStateProvider::Simple {
874 state: BlockStateData {
875 block: &vanilla_blocks::BIRCH_LEAVES,
876 properties: &[
877 ("distance", "7"),
878 ("persistent", "false"),
879 ("waterlogged", "false"),
880 ],
881 },
882 },
883 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
884 base_height: 5i32,
885 height_rand_a: 2i32,
886 height_rand_b: 0i32,
887 }),
888 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
889 radius: IntProvider::Constant(2i32),
890 offset: IntProvider::Constant(0i32),
891 height: IntProvider::Constant(3i32),
892 }),
893 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
894 limit: 1i32,
895 lower_size: 0i32,
896 upper_size: 1i32,
897 min_clipped_height: None,
898 }),
899 decorators: vec![
900 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
901 block_state_provider: BlockStateProvider::Weighted {
902 entries: vec![
903 WeightedBlockState {
904 data: BlockStateData {
905 block: &vanilla_blocks::LEAF_LITTER,
906 properties: &[("facing", "north"), ("segment_amount", "1")],
907 },
908 weight: 1i32,
909 },
910 WeightedBlockState {
911 data: BlockStateData {
912 block: &vanilla_blocks::LEAF_LITTER,
913 properties: &[("facing", "east"), ("segment_amount", "1")],
914 },
915 weight: 1i32,
916 },
917 WeightedBlockState {
918 data: BlockStateData {
919 block: &vanilla_blocks::LEAF_LITTER,
920 properties: &[("facing", "south"), ("segment_amount", "1")],
921 },
922 weight: 1i32,
923 },
924 WeightedBlockState {
925 data: BlockStateData {
926 block: &vanilla_blocks::LEAF_LITTER,
927 properties: &[("facing", "west"), ("segment_amount", "1")],
928 },
929 weight: 1i32,
930 },
931 WeightedBlockState {
932 data: BlockStateData {
933 block: &vanilla_blocks::LEAF_LITTER,
934 properties: &[("facing", "north"), ("segment_amount", "2")],
935 },
936 weight: 1i32,
937 },
938 WeightedBlockState {
939 data: BlockStateData {
940 block: &vanilla_blocks::LEAF_LITTER,
941 properties: &[("facing", "east"), ("segment_amount", "2")],
942 },
943 weight: 1i32,
944 },
945 WeightedBlockState {
946 data: BlockStateData {
947 block: &vanilla_blocks::LEAF_LITTER,
948 properties: &[("facing", "south"), ("segment_amount", "2")],
949 },
950 weight: 1i32,
951 },
952 WeightedBlockState {
953 data: BlockStateData {
954 block: &vanilla_blocks::LEAF_LITTER,
955 properties: &[("facing", "west"), ("segment_amount", "2")],
956 },
957 weight: 1i32,
958 },
959 WeightedBlockState {
960 data: BlockStateData {
961 block: &vanilla_blocks::LEAF_LITTER,
962 properties: &[("facing", "north"), ("segment_amount", "3")],
963 },
964 weight: 1i32,
965 },
966 WeightedBlockState {
967 data: BlockStateData {
968 block: &vanilla_blocks::LEAF_LITTER,
969 properties: &[("facing", "east"), ("segment_amount", "3")],
970 },
971 weight: 1i32,
972 },
973 WeightedBlockState {
974 data: BlockStateData {
975 block: &vanilla_blocks::LEAF_LITTER,
976 properties: &[("facing", "south"), ("segment_amount", "3")],
977 },
978 weight: 1i32,
979 },
980 WeightedBlockState {
981 data: BlockStateData {
982 block: &vanilla_blocks::LEAF_LITTER,
983 properties: &[("facing", "west"), ("segment_amount", "3")],
984 },
985 weight: 1i32,
986 },
987 ],
988 },
989 tries: 96i32,
990 radius: 4i32,
991 height: 2i32,
992 }),
993 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
994 block_state_provider: BlockStateProvider::Weighted {
995 entries: vec![
996 WeightedBlockState {
997 data: BlockStateData {
998 block: &vanilla_blocks::LEAF_LITTER,
999 properties: &[("facing", "north"), ("segment_amount", "1")],
1000 },
1001 weight: 1i32,
1002 },
1003 WeightedBlockState {
1004 data: BlockStateData {
1005 block: &vanilla_blocks::LEAF_LITTER,
1006 properties: &[("facing", "east"), ("segment_amount", "1")],
1007 },
1008 weight: 1i32,
1009 },
1010 WeightedBlockState {
1011 data: BlockStateData {
1012 block: &vanilla_blocks::LEAF_LITTER,
1013 properties: &[("facing", "south"), ("segment_amount", "1")],
1014 },
1015 weight: 1i32,
1016 },
1017 WeightedBlockState {
1018 data: BlockStateData {
1019 block: &vanilla_blocks::LEAF_LITTER,
1020 properties: &[("facing", "west"), ("segment_amount", "1")],
1021 },
1022 weight: 1i32,
1023 },
1024 WeightedBlockState {
1025 data: BlockStateData {
1026 block: &vanilla_blocks::LEAF_LITTER,
1027 properties: &[("facing", "north"), ("segment_amount", "2")],
1028 },
1029 weight: 1i32,
1030 },
1031 WeightedBlockState {
1032 data: BlockStateData {
1033 block: &vanilla_blocks::LEAF_LITTER,
1034 properties: &[("facing", "east"), ("segment_amount", "2")],
1035 },
1036 weight: 1i32,
1037 },
1038 WeightedBlockState {
1039 data: BlockStateData {
1040 block: &vanilla_blocks::LEAF_LITTER,
1041 properties: &[("facing", "south"), ("segment_amount", "2")],
1042 },
1043 weight: 1i32,
1044 },
1045 WeightedBlockState {
1046 data: BlockStateData {
1047 block: &vanilla_blocks::LEAF_LITTER,
1048 properties: &[("facing", "west"), ("segment_amount", "2")],
1049 },
1050 weight: 1i32,
1051 },
1052 WeightedBlockState {
1053 data: BlockStateData {
1054 block: &vanilla_blocks::LEAF_LITTER,
1055 properties: &[("facing", "north"), ("segment_amount", "3")],
1056 },
1057 weight: 1i32,
1058 },
1059 WeightedBlockState {
1060 data: BlockStateData {
1061 block: &vanilla_blocks::LEAF_LITTER,
1062 properties: &[("facing", "east"), ("segment_amount", "3")],
1063 },
1064 weight: 1i32,
1065 },
1066 WeightedBlockState {
1067 data: BlockStateData {
1068 block: &vanilla_blocks::LEAF_LITTER,
1069 properties: &[("facing", "south"), ("segment_amount", "3")],
1070 },
1071 weight: 1i32,
1072 },
1073 WeightedBlockState {
1074 data: BlockStateData {
1075 block: &vanilla_blocks::LEAF_LITTER,
1076 properties: &[("facing", "west"), ("segment_amount", "3")],
1077 },
1078 weight: 1i32,
1079 },
1080 WeightedBlockState {
1081 data: BlockStateData {
1082 block: &vanilla_blocks::LEAF_LITTER,
1083 properties: &[("facing", "north"), ("segment_amount", "4")],
1084 },
1085 weight: 1i32,
1086 },
1087 WeightedBlockState {
1088 data: BlockStateData {
1089 block: &vanilla_blocks::LEAF_LITTER,
1090 properties: &[("facing", "east"), ("segment_amount", "4")],
1091 },
1092 weight: 1i32,
1093 },
1094 WeightedBlockState {
1095 data: BlockStateData {
1096 block: &vanilla_blocks::LEAF_LITTER,
1097 properties: &[("facing", "south"), ("segment_amount", "4")],
1098 },
1099 weight: 1i32,
1100 },
1101 WeightedBlockState {
1102 data: BlockStateData {
1103 block: &vanilla_blocks::LEAF_LITTER,
1104 properties: &[("facing", "west"), ("segment_amount", "4")],
1105 },
1106 weight: 1i32,
1107 },
1108 ],
1109 },
1110 tries: 150i32,
1111 radius: 2i32,
1112 height: 2i32,
1113 }),
1114 ],
1115 root_placer: None,
1116 ignore_vines: true,
1117 }),
1118 id: OnceLock::new(),
1119});
1120pub static BIRCH_TALL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1121 key: Identifier::vanilla_static("birch_tall"),
1122 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
1123 features: vec![
1124 WeightedPlacedFeature {
1125 chance: 0.00625f32,
1126 feature: PlacedFeatureRef::Reference(
1127 &crate::vanilla_placed_features::FALLEN_SUPER_BIRCH_TREE,
1128 ),
1129 },
1130 WeightedPlacedFeature {
1131 chance: 0.5f32,
1132 feature: PlacedFeatureRef::Reference(
1133 &crate::vanilla_placed_features::SUPER_BIRCH_BEES_0002,
1134 ),
1135 },
1136 WeightedPlacedFeature {
1137 chance: 0.0125f32,
1138 feature: PlacedFeatureRef::Reference(
1139 &crate::vanilla_placed_features::FALLEN_BIRCH_TREE,
1140 ),
1141 },
1142 ],
1143 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::BIRCH_BEES_0002),
1144 }),
1145 id: OnceLock::new(),
1146});
1147pub static BLACKSTONE_BLOBS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1148 key: Identifier::vanilla_static("blackstone_blobs"),
1149 kind: ConfiguredFeatureKind::NetherrackReplaceBlobs(NetherrackReplaceBlobsConfiguration {
1150 target: BlockStateData {
1151 block: &vanilla_blocks::NETHERRACK,
1152 properties: &[],
1153 },
1154 state: BlockStateData {
1155 block: &vanilla_blocks::BLACKSTONE,
1156 properties: &[],
1157 },
1158 radius: IntProvider::Uniform {
1159 min_inclusive: 3i32,
1160 max_inclusive: 7i32,
1161 },
1162 }),
1163 id: OnceLock::new(),
1164});
1165pub static BLUE_ICE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1166 key: Identifier::vanilla_static("blue_ice"),
1167 kind: ConfiguredFeatureKind::BlueIce,
1168 id: OnceLock::new(),
1169});
1170pub static BONUS_CHEST: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1171 key: Identifier::vanilla_static("bonus_chest"),
1172 kind: ConfiguredFeatureKind::BonusChest,
1173 id: OnceLock::new(),
1174});
1175pub static BROWN_MUSHROOM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1176 key: Identifier::vanilla_static("brown_mushroom"),
1177 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
1178 to_place: BlockStateProvider::Simple {
1179 state: BlockStateData {
1180 block: &vanilla_blocks::BROWN_MUSHROOM,
1181 properties: &[],
1182 },
1183 },
1184 schedule_tick: false,
1185 }),
1186 id: OnceLock::new(),
1187});
1188pub static BUSH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1189 key: Identifier::vanilla_static("bush"),
1190 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
1191 to_place: BlockStateProvider::Simple {
1192 state: BlockStateData {
1193 block: &vanilla_blocks::BUSH,
1194 properties: &[],
1195 },
1196 },
1197 schedule_tick: false,
1198 }),
1199 id: OnceLock::new(),
1200});
1201pub static CACTUS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1202 key: Identifier::vanilla_static("cactus"),
1203 kind: ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
1204 direction: Direction::Up,
1205 allowed_placement: BlockPredicate::MatchingBlockTag {
1206 tag: Identifier::vanilla_static("air"),
1207 offset: [0i32, 0i32, 0i32],
1208 },
1209 layers: vec![
1210 BlockColumnLayer {
1211 height: IntProvider::BiasedToBottom {
1212 min_inclusive: 1i32,
1213 max_inclusive: 3i32,
1214 },
1215 provider: BlockStateProvider::Simple {
1216 state: BlockStateData {
1217 block: &vanilla_blocks::CACTUS,
1218 properties: &[("age", "0")],
1219 },
1220 },
1221 },
1222 BlockColumnLayer {
1223 height: IntProvider::WeightedList {
1224 distribution: vec![
1225 WeightedIntProvider {
1226 data: IntProvider::Constant(0i32),
1227 weight: 3i32,
1228 },
1229 WeightedIntProvider {
1230 data: IntProvider::Constant(1i32),
1231 weight: 1i32,
1232 },
1233 ],
1234 },
1235 provider: BlockStateProvider::Simple {
1236 state: BlockStateData {
1237 block: &vanilla_blocks::CACTUS_FLOWER,
1238 properties: &[],
1239 },
1240 },
1241 },
1242 ],
1243 prioritize_tip: false,
1244 }),
1245 id: OnceLock::new(),
1246});
1247pub static CAVE_VINE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1248 key: Identifier::vanilla_static("cave_vine"),
1249 kind: ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
1250 direction: Direction::Down,
1251 allowed_placement: BlockPredicate::MatchingBlockTag {
1252 tag: Identifier::vanilla_static("air"),
1253 offset: [0i32, 0i32, 0i32],
1254 },
1255 layers: vec![
1256 BlockColumnLayer {
1257 height: IntProvider::WeightedList {
1258 distribution: vec![
1259 WeightedIntProvider {
1260 data: IntProvider::Uniform {
1261 min_inclusive: 0i32,
1262 max_inclusive: 19i32,
1263 },
1264 weight: 2i32,
1265 },
1266 WeightedIntProvider {
1267 data: IntProvider::Uniform {
1268 min_inclusive: 0i32,
1269 max_inclusive: 2i32,
1270 },
1271 weight: 3i32,
1272 },
1273 WeightedIntProvider {
1274 data: IntProvider::Uniform {
1275 min_inclusive: 0i32,
1276 max_inclusive: 6i32,
1277 },
1278 weight: 10i32,
1279 },
1280 ],
1281 },
1282 provider: BlockStateProvider::Weighted {
1283 entries: vec![
1284 WeightedBlockState {
1285 data: BlockStateData {
1286 block: &vanilla_blocks::CAVE_VINES_PLANT,
1287 properties: &[("berries", "false")],
1288 },
1289 weight: 4i32,
1290 },
1291 WeightedBlockState {
1292 data: BlockStateData {
1293 block: &vanilla_blocks::CAVE_VINES_PLANT,
1294 properties: &[("berries", "true")],
1295 },
1296 weight: 1i32,
1297 },
1298 ],
1299 },
1300 },
1301 BlockColumnLayer {
1302 height: IntProvider::Constant(1i32),
1303 provider: BlockStateProvider::RandomizedInt {
1304 property: "age".to_string(),
1305 source: Box::new(BlockStateProvider::Weighted {
1306 entries: vec![
1307 WeightedBlockState {
1308 data: BlockStateData {
1309 block: &vanilla_blocks::CAVE_VINES,
1310 properties: &[("age", "0"), ("berries", "false")],
1311 },
1312 weight: 4i32,
1313 },
1314 WeightedBlockState {
1315 data: BlockStateData {
1316 block: &vanilla_blocks::CAVE_VINES,
1317 properties: &[("age", "0"), ("berries", "true")],
1318 },
1319 weight: 1i32,
1320 },
1321 ],
1322 }),
1323 values: IntProvider::Uniform {
1324 min_inclusive: 23i32,
1325 max_inclusive: 25i32,
1326 },
1327 },
1328 },
1329 ],
1330 prioritize_tip: true,
1331 }),
1332 id: OnceLock::new(),
1333});
1334pub static CAVE_VINE_IN_MOSS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1335 key: Identifier::vanilla_static("cave_vine_in_moss"),
1336 kind: ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
1337 direction: Direction::Down,
1338 allowed_placement: BlockPredicate::MatchingBlockTag {
1339 tag: Identifier::vanilla_static("air"),
1340 offset: [0i32, 0i32, 0i32],
1341 },
1342 layers: vec![
1343 BlockColumnLayer {
1344 height: IntProvider::WeightedList {
1345 distribution: vec![
1346 WeightedIntProvider {
1347 data: IntProvider::Uniform {
1348 min_inclusive: 0i32,
1349 max_inclusive: 3i32,
1350 },
1351 weight: 5i32,
1352 },
1353 WeightedIntProvider {
1354 data: IntProvider::Uniform {
1355 min_inclusive: 1i32,
1356 max_inclusive: 7i32,
1357 },
1358 weight: 1i32,
1359 },
1360 ],
1361 },
1362 provider: BlockStateProvider::Weighted {
1363 entries: vec![
1364 WeightedBlockState {
1365 data: BlockStateData {
1366 block: &vanilla_blocks::CAVE_VINES_PLANT,
1367 properties: &[("berries", "false")],
1368 },
1369 weight: 4i32,
1370 },
1371 WeightedBlockState {
1372 data: BlockStateData {
1373 block: &vanilla_blocks::CAVE_VINES_PLANT,
1374 properties: &[("berries", "true")],
1375 },
1376 weight: 1i32,
1377 },
1378 ],
1379 },
1380 },
1381 BlockColumnLayer {
1382 height: IntProvider::Constant(1i32),
1383 provider: BlockStateProvider::RandomizedInt {
1384 property: "age".to_string(),
1385 source: Box::new(BlockStateProvider::Weighted {
1386 entries: vec![
1387 WeightedBlockState {
1388 data: BlockStateData {
1389 block: &vanilla_blocks::CAVE_VINES,
1390 properties: &[("age", "0"), ("berries", "false")],
1391 },
1392 weight: 4i32,
1393 },
1394 WeightedBlockState {
1395 data: BlockStateData {
1396 block: &vanilla_blocks::CAVE_VINES,
1397 properties: &[("age", "0"), ("berries", "true")],
1398 },
1399 weight: 1i32,
1400 },
1401 ],
1402 }),
1403 values: IntProvider::Uniform {
1404 min_inclusive: 23i32,
1405 max_inclusive: 25i32,
1406 },
1407 },
1408 },
1409 ],
1410 prioritize_tip: true,
1411 }),
1412 id: OnceLock::new(),
1413});
1414pub static CHERRY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1415 key: Identifier::vanilla_static("cherry"),
1416 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
1417 trunk_provider: BlockStateProvider::Simple {
1418 state: BlockStateData {
1419 block: &vanilla_blocks::CHERRY_LOG,
1420 properties: &[("axis", "y")],
1421 },
1422 },
1423 below_trunk_provider: BlockStateProvider::RuleBased {
1424 fallback: None,
1425 rules: vec![RuleBasedStateProviderRule {
1426 if_true: BlockPredicate::Not {
1427 predicate: Box::new(BlockPredicate::MatchingBlockTag {
1428 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
1429 offset: [0i32, 0i32, 0i32],
1430 }),
1431 },
1432 then: BlockStateProvider::Simple {
1433 state: BlockStateData {
1434 block: &vanilla_blocks::DIRT,
1435 properties: &[],
1436 },
1437 },
1438 }],
1439 },
1440 foliage_provider: BlockStateProvider::Simple {
1441 state: BlockStateData {
1442 block: &vanilla_blocks::CHERRY_LEAVES,
1443 properties: &[
1444 ("distance", "7"),
1445 ("persistent", "false"),
1446 ("waterlogged", "false"),
1447 ],
1448 },
1449 },
1450 trunk_placer: TrunkPlacer::Cherry(CherryTrunkPlacer {
1451 base_height: 7i32,
1452 height_rand_a: 1i32,
1453 height_rand_b: 0i32,
1454 branch_count: IntProvider::WeightedList {
1455 distribution: vec![
1456 WeightedIntProvider {
1457 data: IntProvider::Constant(1i32),
1458 weight: 1i32,
1459 },
1460 WeightedIntProvider {
1461 data: IntProvider::Constant(2i32),
1462 weight: 1i32,
1463 },
1464 WeightedIntProvider {
1465 data: IntProvider::Constant(3i32),
1466 weight: 1i32,
1467 },
1468 ],
1469 },
1470 branch_horizontal_length: IntProvider::Uniform {
1471 min_inclusive: 2i32,
1472 max_inclusive: 4i32,
1473 },
1474 branch_start_offset_from_top: UniformIntProvider {
1475 min_inclusive: -4i32,
1476 max_inclusive: -3i32,
1477 },
1478 branch_end_offset_from_top: IntProvider::Uniform {
1479 min_inclusive: -1i32,
1480 max_inclusive: 0i32,
1481 },
1482 }),
1483 foliage_placer: FoliagePlacer::Cherry(CherryFoliagePlacer {
1484 radius: IntProvider::Constant(4i32),
1485 offset: IntProvider::Constant(0i32),
1486 height: IntProvider::Constant(5i32),
1487 wide_bottom_layer_hole_chance: 0.25f32,
1488 corner_hole_chance: 0.25f32,
1489 hanging_leaves_chance: 0.16666667f32,
1490 hanging_leaves_extension_chance: 0.33333334f32,
1491 }),
1492 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
1493 limit: 1i32,
1494 lower_size: 0i32,
1495 upper_size: 2i32,
1496 min_clipped_height: None,
1497 }),
1498 decorators: vec![],
1499 root_placer: None,
1500 ignore_vines: true,
1501 }),
1502 id: OnceLock::new(),
1503});
1504pub static CHERRY_BEES_005: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1505 key: Identifier::vanilla_static("cherry_bees_005"),
1506 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
1507 trunk_provider: BlockStateProvider::Simple {
1508 state: BlockStateData {
1509 block: &vanilla_blocks::CHERRY_LOG,
1510 properties: &[("axis", "y")],
1511 },
1512 },
1513 below_trunk_provider: BlockStateProvider::RuleBased {
1514 fallback: None,
1515 rules: vec![RuleBasedStateProviderRule {
1516 if_true: BlockPredicate::Not {
1517 predicate: Box::new(BlockPredicate::MatchingBlockTag {
1518 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
1519 offset: [0i32, 0i32, 0i32],
1520 }),
1521 },
1522 then: BlockStateProvider::Simple {
1523 state: BlockStateData {
1524 block: &vanilla_blocks::DIRT,
1525 properties: &[],
1526 },
1527 },
1528 }],
1529 },
1530 foliage_provider: BlockStateProvider::Simple {
1531 state: BlockStateData {
1532 block: &vanilla_blocks::CHERRY_LEAVES,
1533 properties: &[
1534 ("distance", "7"),
1535 ("persistent", "false"),
1536 ("waterlogged", "false"),
1537 ],
1538 },
1539 },
1540 trunk_placer: TrunkPlacer::Cherry(CherryTrunkPlacer {
1541 base_height: 7i32,
1542 height_rand_a: 1i32,
1543 height_rand_b: 0i32,
1544 branch_count: IntProvider::WeightedList {
1545 distribution: vec![
1546 WeightedIntProvider {
1547 data: IntProvider::Constant(1i32),
1548 weight: 1i32,
1549 },
1550 WeightedIntProvider {
1551 data: IntProvider::Constant(2i32),
1552 weight: 1i32,
1553 },
1554 WeightedIntProvider {
1555 data: IntProvider::Constant(3i32),
1556 weight: 1i32,
1557 },
1558 ],
1559 },
1560 branch_horizontal_length: IntProvider::Uniform {
1561 min_inclusive: 2i32,
1562 max_inclusive: 4i32,
1563 },
1564 branch_start_offset_from_top: UniformIntProvider {
1565 min_inclusive: -4i32,
1566 max_inclusive: -3i32,
1567 },
1568 branch_end_offset_from_top: IntProvider::Uniform {
1569 min_inclusive: -1i32,
1570 max_inclusive: 0i32,
1571 },
1572 }),
1573 foliage_placer: FoliagePlacer::Cherry(CherryFoliagePlacer {
1574 radius: IntProvider::Constant(4i32),
1575 offset: IntProvider::Constant(0i32),
1576 height: IntProvider::Constant(5i32),
1577 wide_bottom_layer_hole_chance: 0.25f32,
1578 corner_hole_chance: 0.25f32,
1579 hanging_leaves_chance: 0.16666667f32,
1580 hanging_leaves_extension_chance: 0.33333334f32,
1581 }),
1582 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
1583 limit: 1i32,
1584 lower_size: 0i32,
1585 upper_size: 2i32,
1586 min_clipped_height: None,
1587 }),
1588 decorators: vec![TreeDecorator::Beehive {
1589 probability: 0.05f32,
1590 }],
1591 root_placer: None,
1592 ignore_vines: true,
1593 }),
1594 id: OnceLock::new(),
1595});
1596pub static CHORUS_PLANT: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1597 key: Identifier::vanilla_static("chorus_plant"),
1598 kind: ConfiguredFeatureKind::ChorusPlant,
1599 id: OnceLock::new(),
1600});
1601pub static CLAY_POOL_WITH_DRIPLEAVES: LazyLock<ConfiguredFeature> =
1602 LazyLock::new(|| ConfiguredFeature {
1603 key: Identifier::vanilla_static("clay_pool_with_dripleaves"),
1604 kind: ConfiguredFeatureKind::WaterloggedVegetationPatch(VegetationPatchConfiguration {
1605 replaceable: Identifier::vanilla_static("lush_ground_replaceable"),
1606 ground_state: BlockStateProvider::Simple {
1607 state: BlockStateData {
1608 block: &vanilla_blocks::CLAY,
1609 properties: &[],
1610 },
1611 },
1612 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
1613 feature: ConfiguredFeatureRef::Reference(
1614 &crate::vanilla_configured_features::DRIPLEAF,
1615 ),
1616 placement: vec![],
1617 })),
1618 surface: VerticalSurface::Floor,
1619 depth: IntProvider::Constant(3i32),
1620 extra_bottom_block_chance: 0.8f32,
1621 vertical_range: 5i32,
1622 vegetation_chance: 0.1f32,
1623 xz_radius: IntProvider::Uniform {
1624 min_inclusive: 4i32,
1625 max_inclusive: 7i32,
1626 },
1627 extra_edge_column_chance: 0.7f32,
1628 }),
1629 id: OnceLock::new(),
1630 });
1631pub static CLAY_WITH_DRIPLEAVES: LazyLock<ConfiguredFeature> =
1632 LazyLock::new(|| ConfiguredFeature {
1633 key: Identifier::vanilla_static("clay_with_dripleaves"),
1634 kind: ConfiguredFeatureKind::VegetationPatch(VegetationPatchConfiguration {
1635 replaceable: Identifier::vanilla_static("lush_ground_replaceable"),
1636 ground_state: BlockStateProvider::Simple {
1637 state: BlockStateData {
1638 block: &vanilla_blocks::CLAY,
1639 properties: &[],
1640 },
1641 },
1642 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
1643 feature: ConfiguredFeatureRef::Reference(
1644 &crate::vanilla_configured_features::DRIPLEAF,
1645 ),
1646 placement: vec![],
1647 })),
1648 surface: VerticalSurface::Floor,
1649 depth: IntProvider::Constant(3i32),
1650 extra_bottom_block_chance: 0.8f32,
1651 vertical_range: 2i32,
1652 vegetation_chance: 0.05f32,
1653 xz_radius: IntProvider::Uniform {
1654 min_inclusive: 4i32,
1655 max_inclusive: 7i32,
1656 },
1657 extra_edge_column_chance: 0.7f32,
1658 }),
1659 id: OnceLock::new(),
1660 });
1661pub static CRIMSON_FOREST_VEGETATION: LazyLock<ConfiguredFeature> =
1662 LazyLock::new(|| ConfiguredFeature {
1663 key: Identifier::vanilla_static("crimson_forest_vegetation"),
1664 kind: ConfiguredFeatureKind::NetherForestVegetation(NetherForestVegetationConfiguration {
1665 state_provider: BlockStateProvider::Weighted {
1666 entries: vec![
1667 WeightedBlockState {
1668 data: BlockStateData {
1669 block: &vanilla_blocks::CRIMSON_ROOTS,
1670 properties: &[],
1671 },
1672 weight: 87i32,
1673 },
1674 WeightedBlockState {
1675 data: BlockStateData {
1676 block: &vanilla_blocks::CRIMSON_FUNGUS,
1677 properties: &[],
1678 },
1679 weight: 11i32,
1680 },
1681 WeightedBlockState {
1682 data: BlockStateData {
1683 block: &vanilla_blocks::WARPED_FUNGUS,
1684 properties: &[],
1685 },
1686 weight: 1i32,
1687 },
1688 ],
1689 },
1690 spread_width: 8i32,
1691 spread_height: 4i32,
1692 }),
1693 id: OnceLock::new(),
1694 });
1695pub static CRIMSON_FOREST_VEGETATION_BONEMEAL: LazyLock<ConfiguredFeature> =
1696 LazyLock::new(|| ConfiguredFeature {
1697 key: Identifier::vanilla_static("crimson_forest_vegetation_bonemeal"),
1698 kind: ConfiguredFeatureKind::NetherForestVegetation(NetherForestVegetationConfiguration {
1699 state_provider: BlockStateProvider::Weighted {
1700 entries: vec![
1701 WeightedBlockState {
1702 data: BlockStateData {
1703 block: &vanilla_blocks::CRIMSON_ROOTS,
1704 properties: &[],
1705 },
1706 weight: 87i32,
1707 },
1708 WeightedBlockState {
1709 data: BlockStateData {
1710 block: &vanilla_blocks::CRIMSON_FUNGUS,
1711 properties: &[],
1712 },
1713 weight: 11i32,
1714 },
1715 WeightedBlockState {
1716 data: BlockStateData {
1717 block: &vanilla_blocks::WARPED_FUNGUS,
1718 properties: &[],
1719 },
1720 weight: 1i32,
1721 },
1722 ],
1723 },
1724 spread_width: 3i32,
1725 spread_height: 1i32,
1726 }),
1727 id: OnceLock::new(),
1728 });
1729pub static CRIMSON_FUNGUS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1730 key: Identifier::vanilla_static("crimson_fungus"),
1731 kind: ConfiguredFeatureKind::HugeFungus(HugeFungusConfiguration {
1732 valid_base_block: BlockStateData {
1733 block: &vanilla_blocks::CRIMSON_NYLIUM,
1734 properties: &[],
1735 },
1736 stem_state: BlockStateData {
1737 block: &vanilla_blocks::CRIMSON_STEM,
1738 properties: &[("axis", "y")],
1739 },
1740 hat_state: BlockStateData {
1741 block: &vanilla_blocks::NETHER_WART_BLOCK,
1742 properties: &[],
1743 },
1744 decor_state: BlockStateData {
1745 block: &vanilla_blocks::SHROOMLIGHT,
1746 properties: &[],
1747 },
1748 replaceable_blocks: BlockPredicate::MatchingBlocks {
1749 blocks: BlockRefList(vec![
1750 &vanilla_blocks::OAK_SAPLING,
1751 &vanilla_blocks::SPRUCE_SAPLING,
1752 &vanilla_blocks::BIRCH_SAPLING,
1753 &vanilla_blocks::JUNGLE_SAPLING,
1754 &vanilla_blocks::ACACIA_SAPLING,
1755 &vanilla_blocks::CHERRY_SAPLING,
1756 &vanilla_blocks::DARK_OAK_SAPLING,
1757 &vanilla_blocks::PALE_OAK_SAPLING,
1758 &vanilla_blocks::MANGROVE_PROPAGULE,
1759 &vanilla_blocks::DANDELION,
1760 &vanilla_blocks::TORCHFLOWER,
1761 &vanilla_blocks::POPPY,
1762 &vanilla_blocks::BLUE_ORCHID,
1763 &vanilla_blocks::ALLIUM,
1764 &vanilla_blocks::AZURE_BLUET,
1765 &vanilla_blocks::RED_TULIP,
1766 &vanilla_blocks::ORANGE_TULIP,
1767 &vanilla_blocks::WHITE_TULIP,
1768 &vanilla_blocks::PINK_TULIP,
1769 &vanilla_blocks::OXEYE_DAISY,
1770 &vanilla_blocks::CORNFLOWER,
1771 &vanilla_blocks::WITHER_ROSE,
1772 &vanilla_blocks::LILY_OF_THE_VALLEY,
1773 &vanilla_blocks::BROWN_MUSHROOM,
1774 &vanilla_blocks::RED_MUSHROOM,
1775 &vanilla_blocks::WHEAT,
1776 &vanilla_blocks::SUGAR_CANE,
1777 &vanilla_blocks::ATTACHED_PUMPKIN_STEM,
1778 &vanilla_blocks::ATTACHED_MELON_STEM,
1779 &vanilla_blocks::PUMPKIN_STEM,
1780 &vanilla_blocks::MELON_STEM,
1781 &vanilla_blocks::LILY_PAD,
1782 &vanilla_blocks::NETHER_WART,
1783 &vanilla_blocks::COCOA,
1784 &vanilla_blocks::CARROTS,
1785 &vanilla_blocks::POTATOES,
1786 &vanilla_blocks::CHORUS_PLANT,
1787 &vanilla_blocks::CHORUS_FLOWER,
1788 &vanilla_blocks::TORCHFLOWER_CROP,
1789 &vanilla_blocks::PITCHER_CROP,
1790 &vanilla_blocks::BEETROOTS,
1791 &vanilla_blocks::SWEET_BERRY_BUSH,
1792 &vanilla_blocks::WARPED_FUNGUS,
1793 &vanilla_blocks::CRIMSON_FUNGUS,
1794 &vanilla_blocks::WEEPING_VINES,
1795 &vanilla_blocks::WEEPING_VINES_PLANT,
1796 &vanilla_blocks::TWISTING_VINES,
1797 &vanilla_blocks::TWISTING_VINES_PLANT,
1798 &vanilla_blocks::CAVE_VINES,
1799 &vanilla_blocks::CAVE_VINES_PLANT,
1800 &vanilla_blocks::SPORE_BLOSSOM,
1801 &vanilla_blocks::AZALEA,
1802 &vanilla_blocks::FLOWERING_AZALEA,
1803 &vanilla_blocks::MOSS_CARPET,
1804 &vanilla_blocks::PINK_PETALS,
1805 &vanilla_blocks::WILDFLOWERS,
1806 &vanilla_blocks::BIG_DRIPLEAF,
1807 &vanilla_blocks::BIG_DRIPLEAF_STEM,
1808 &vanilla_blocks::SMALL_DRIPLEAF,
1809 ]),
1810 offset: [0i32, 0i32, 0i32],
1811 },
1812 planted: false,
1813 }),
1814 id: OnceLock::new(),
1815});
1816pub static CRIMSON_FUNGUS_PLANTED: LazyLock<ConfiguredFeature> =
1817 LazyLock::new(|| ConfiguredFeature {
1818 key: Identifier::vanilla_static("crimson_fungus_planted"),
1819 kind: ConfiguredFeatureKind::HugeFungus(HugeFungusConfiguration {
1820 valid_base_block: BlockStateData {
1821 block: &vanilla_blocks::CRIMSON_NYLIUM,
1822 properties: &[],
1823 },
1824 stem_state: BlockStateData {
1825 block: &vanilla_blocks::CRIMSON_STEM,
1826 properties: &[("axis", "y")],
1827 },
1828 hat_state: BlockStateData {
1829 block: &vanilla_blocks::NETHER_WART_BLOCK,
1830 properties: &[],
1831 },
1832 decor_state: BlockStateData {
1833 block: &vanilla_blocks::SHROOMLIGHT,
1834 properties: &[],
1835 },
1836 replaceable_blocks: BlockPredicate::MatchingBlocks {
1837 blocks: BlockRefList(vec![
1838 &vanilla_blocks::OAK_SAPLING,
1839 &vanilla_blocks::SPRUCE_SAPLING,
1840 &vanilla_blocks::BIRCH_SAPLING,
1841 &vanilla_blocks::JUNGLE_SAPLING,
1842 &vanilla_blocks::ACACIA_SAPLING,
1843 &vanilla_blocks::CHERRY_SAPLING,
1844 &vanilla_blocks::DARK_OAK_SAPLING,
1845 &vanilla_blocks::PALE_OAK_SAPLING,
1846 &vanilla_blocks::MANGROVE_PROPAGULE,
1847 &vanilla_blocks::DANDELION,
1848 &vanilla_blocks::TORCHFLOWER,
1849 &vanilla_blocks::POPPY,
1850 &vanilla_blocks::BLUE_ORCHID,
1851 &vanilla_blocks::ALLIUM,
1852 &vanilla_blocks::AZURE_BLUET,
1853 &vanilla_blocks::RED_TULIP,
1854 &vanilla_blocks::ORANGE_TULIP,
1855 &vanilla_blocks::WHITE_TULIP,
1856 &vanilla_blocks::PINK_TULIP,
1857 &vanilla_blocks::OXEYE_DAISY,
1858 &vanilla_blocks::CORNFLOWER,
1859 &vanilla_blocks::WITHER_ROSE,
1860 &vanilla_blocks::LILY_OF_THE_VALLEY,
1861 &vanilla_blocks::BROWN_MUSHROOM,
1862 &vanilla_blocks::RED_MUSHROOM,
1863 &vanilla_blocks::WHEAT,
1864 &vanilla_blocks::SUGAR_CANE,
1865 &vanilla_blocks::ATTACHED_PUMPKIN_STEM,
1866 &vanilla_blocks::ATTACHED_MELON_STEM,
1867 &vanilla_blocks::PUMPKIN_STEM,
1868 &vanilla_blocks::MELON_STEM,
1869 &vanilla_blocks::LILY_PAD,
1870 &vanilla_blocks::NETHER_WART,
1871 &vanilla_blocks::COCOA,
1872 &vanilla_blocks::CARROTS,
1873 &vanilla_blocks::POTATOES,
1874 &vanilla_blocks::CHORUS_PLANT,
1875 &vanilla_blocks::CHORUS_FLOWER,
1876 &vanilla_blocks::TORCHFLOWER_CROP,
1877 &vanilla_blocks::PITCHER_CROP,
1878 &vanilla_blocks::BEETROOTS,
1879 &vanilla_blocks::SWEET_BERRY_BUSH,
1880 &vanilla_blocks::WARPED_FUNGUS,
1881 &vanilla_blocks::CRIMSON_FUNGUS,
1882 &vanilla_blocks::WEEPING_VINES,
1883 &vanilla_blocks::WEEPING_VINES_PLANT,
1884 &vanilla_blocks::TWISTING_VINES,
1885 &vanilla_blocks::TWISTING_VINES_PLANT,
1886 &vanilla_blocks::CAVE_VINES,
1887 &vanilla_blocks::CAVE_VINES_PLANT,
1888 &vanilla_blocks::SPORE_BLOSSOM,
1889 &vanilla_blocks::AZALEA,
1890 &vanilla_blocks::FLOWERING_AZALEA,
1891 &vanilla_blocks::MOSS_CARPET,
1892 &vanilla_blocks::PINK_PETALS,
1893 &vanilla_blocks::WILDFLOWERS,
1894 &vanilla_blocks::BIG_DRIPLEAF,
1895 &vanilla_blocks::BIG_DRIPLEAF_STEM,
1896 &vanilla_blocks::SMALL_DRIPLEAF,
1897 ]),
1898 offset: [0i32, 0i32, 0i32],
1899 },
1900 planted: true,
1901 }),
1902 id: OnceLock::new(),
1903 });
1904pub static CRIMSON_ROOTS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1905 key: Identifier::vanilla_static("crimson_roots"),
1906 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
1907 to_place: BlockStateProvider::Simple {
1908 state: BlockStateData {
1909 block: &vanilla_blocks::CRIMSON_ROOTS,
1910 properties: &[],
1911 },
1912 },
1913 schedule_tick: false,
1914 }),
1915 id: OnceLock::new(),
1916});
1917pub static DARK_FOREST_VEGETATION: LazyLock<ConfiguredFeature> =
1918 LazyLock::new(|| ConfiguredFeature {
1919 key: Identifier::vanilla_static("dark_forest_vegetation"),
1920 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
1921 features: vec![
1922 WeightedPlacedFeature {
1923 chance: 0.025f32,
1924 feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
1925 feature: ConfiguredFeatureRef::Reference(
1926 &crate::vanilla_configured_features::HUGE_BROWN_MUSHROOM,
1927 ),
1928 placement: vec![],
1929 })),
1930 },
1931 WeightedPlacedFeature {
1932 chance: 0.05f32,
1933 feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
1934 feature: ConfiguredFeatureRef::Reference(
1935 &crate::vanilla_configured_features::HUGE_RED_MUSHROOM,
1936 ),
1937 placement: vec![],
1938 })),
1939 },
1940 WeightedPlacedFeature {
1941 chance: 0.6666667f32,
1942 feature: PlacedFeatureRef::Reference(
1943 &crate::vanilla_placed_features::DARK_OAK_LEAF_LITTER,
1944 ),
1945 },
1946 WeightedPlacedFeature {
1947 chance: 0.0025f32,
1948 feature: PlacedFeatureRef::Reference(
1949 &crate::vanilla_placed_features::FALLEN_BIRCH_TREE,
1950 ),
1951 },
1952 WeightedPlacedFeature {
1953 chance: 0.2f32,
1954 feature: PlacedFeatureRef::Reference(
1955 &crate::vanilla_placed_features::BIRCH_LEAF_LITTER,
1956 ),
1957 },
1958 WeightedPlacedFeature {
1959 chance: 0.0125f32,
1960 feature: PlacedFeatureRef::Reference(
1961 &crate::vanilla_placed_features::FALLEN_OAK_TREE,
1962 ),
1963 },
1964 WeightedPlacedFeature {
1965 chance: 0.1f32,
1966 feature: PlacedFeatureRef::Reference(
1967 &crate::vanilla_placed_features::FANCY_OAK_LEAF_LITTER,
1968 ),
1969 },
1970 ],
1971 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::OAK_LEAF_LITTER),
1972 }),
1973 id: OnceLock::new(),
1974 });
1975pub static DARK_OAK: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
1976 key: Identifier::vanilla_static("dark_oak"),
1977 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
1978 trunk_provider: BlockStateProvider::Simple {
1979 state: BlockStateData {
1980 block: &vanilla_blocks::DARK_OAK_LOG,
1981 properties: &[("axis", "y")],
1982 },
1983 },
1984 below_trunk_provider: BlockStateProvider::RuleBased {
1985 fallback: None,
1986 rules: vec![RuleBasedStateProviderRule {
1987 if_true: BlockPredicate::Not {
1988 predicate: Box::new(BlockPredicate::MatchingBlockTag {
1989 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
1990 offset: [0i32, 0i32, 0i32],
1991 }),
1992 },
1993 then: BlockStateProvider::Simple {
1994 state: BlockStateData {
1995 block: &vanilla_blocks::DIRT,
1996 properties: &[],
1997 },
1998 },
1999 }],
2000 },
2001 foliage_provider: BlockStateProvider::Simple {
2002 state: BlockStateData {
2003 block: &vanilla_blocks::DARK_OAK_LEAVES,
2004 properties: &[
2005 ("distance", "7"),
2006 ("persistent", "false"),
2007 ("waterlogged", "false"),
2008 ],
2009 },
2010 },
2011 trunk_placer: TrunkPlacer::DarkOak(TrunkPlacerBase {
2012 base_height: 6i32,
2013 height_rand_a: 2i32,
2014 height_rand_b: 1i32,
2015 }),
2016 foliage_placer: FoliagePlacer::DarkOak(FoliagePlacerBase {
2017 radius: IntProvider::Constant(0i32),
2018 offset: IntProvider::Constant(0i32),
2019 }),
2020 minimum_size: FeatureSize::ThreeLayers(ThreeLayersFeatureSize {
2021 limit: 1i32,
2022 lower_size: 0i32,
2023 middle_size: 1i32,
2024 upper_limit: 1i32,
2025 upper_size: 2i32,
2026 min_clipped_height: None,
2027 }),
2028 decorators: vec![],
2029 root_placer: None,
2030 ignore_vines: true,
2031 }),
2032 id: OnceLock::new(),
2033});
2034pub static DARK_OAK_LEAF_LITTER: LazyLock<ConfiguredFeature> =
2035 LazyLock::new(|| ConfiguredFeature {
2036 key: Identifier::vanilla_static("dark_oak_leaf_litter"),
2037 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
2038 trunk_provider: BlockStateProvider::Simple {
2039 state: BlockStateData {
2040 block: &vanilla_blocks::DARK_OAK_LOG,
2041 properties: &[("axis", "y")],
2042 },
2043 },
2044 below_trunk_provider: BlockStateProvider::RuleBased {
2045 fallback: None,
2046 rules: vec![RuleBasedStateProviderRule {
2047 if_true: BlockPredicate::Not {
2048 predicate: Box::new(BlockPredicate::MatchingBlockTag {
2049 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
2050 offset: [0i32, 0i32, 0i32],
2051 }),
2052 },
2053 then: BlockStateProvider::Simple {
2054 state: BlockStateData {
2055 block: &vanilla_blocks::DIRT,
2056 properties: &[],
2057 },
2058 },
2059 }],
2060 },
2061 foliage_provider: BlockStateProvider::Simple {
2062 state: BlockStateData {
2063 block: &vanilla_blocks::DARK_OAK_LEAVES,
2064 properties: &[
2065 ("distance", "7"),
2066 ("persistent", "false"),
2067 ("waterlogged", "false"),
2068 ],
2069 },
2070 },
2071 trunk_placer: TrunkPlacer::DarkOak(TrunkPlacerBase {
2072 base_height: 6i32,
2073 height_rand_a: 2i32,
2074 height_rand_b: 1i32,
2075 }),
2076 foliage_placer: FoliagePlacer::DarkOak(FoliagePlacerBase {
2077 radius: IntProvider::Constant(0i32),
2078 offset: IntProvider::Constant(0i32),
2079 }),
2080 minimum_size: FeatureSize::ThreeLayers(ThreeLayersFeatureSize {
2081 limit: 1i32,
2082 lower_size: 0i32,
2083 middle_size: 1i32,
2084 upper_limit: 1i32,
2085 upper_size: 2i32,
2086 min_clipped_height: None,
2087 }),
2088 decorators: vec![
2089 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
2090 block_state_provider: BlockStateProvider::Weighted {
2091 entries: vec![
2092 WeightedBlockState {
2093 data: BlockStateData {
2094 block: &vanilla_blocks::LEAF_LITTER,
2095 properties: &[("facing", "north"), ("segment_amount", "1")],
2096 },
2097 weight: 1i32,
2098 },
2099 WeightedBlockState {
2100 data: BlockStateData {
2101 block: &vanilla_blocks::LEAF_LITTER,
2102 properties: &[("facing", "east"), ("segment_amount", "1")],
2103 },
2104 weight: 1i32,
2105 },
2106 WeightedBlockState {
2107 data: BlockStateData {
2108 block: &vanilla_blocks::LEAF_LITTER,
2109 properties: &[("facing", "south"), ("segment_amount", "1")],
2110 },
2111 weight: 1i32,
2112 },
2113 WeightedBlockState {
2114 data: BlockStateData {
2115 block: &vanilla_blocks::LEAF_LITTER,
2116 properties: &[("facing", "west"), ("segment_amount", "1")],
2117 },
2118 weight: 1i32,
2119 },
2120 WeightedBlockState {
2121 data: BlockStateData {
2122 block: &vanilla_blocks::LEAF_LITTER,
2123 properties: &[("facing", "north"), ("segment_amount", "2")],
2124 },
2125 weight: 1i32,
2126 },
2127 WeightedBlockState {
2128 data: BlockStateData {
2129 block: &vanilla_blocks::LEAF_LITTER,
2130 properties: &[("facing", "east"), ("segment_amount", "2")],
2131 },
2132 weight: 1i32,
2133 },
2134 WeightedBlockState {
2135 data: BlockStateData {
2136 block: &vanilla_blocks::LEAF_LITTER,
2137 properties: &[("facing", "south"), ("segment_amount", "2")],
2138 },
2139 weight: 1i32,
2140 },
2141 WeightedBlockState {
2142 data: BlockStateData {
2143 block: &vanilla_blocks::LEAF_LITTER,
2144 properties: &[("facing", "west"), ("segment_amount", "2")],
2145 },
2146 weight: 1i32,
2147 },
2148 WeightedBlockState {
2149 data: BlockStateData {
2150 block: &vanilla_blocks::LEAF_LITTER,
2151 properties: &[("facing", "north"), ("segment_amount", "3")],
2152 },
2153 weight: 1i32,
2154 },
2155 WeightedBlockState {
2156 data: BlockStateData {
2157 block: &vanilla_blocks::LEAF_LITTER,
2158 properties: &[("facing", "east"), ("segment_amount", "3")],
2159 },
2160 weight: 1i32,
2161 },
2162 WeightedBlockState {
2163 data: BlockStateData {
2164 block: &vanilla_blocks::LEAF_LITTER,
2165 properties: &[("facing", "south"), ("segment_amount", "3")],
2166 },
2167 weight: 1i32,
2168 },
2169 WeightedBlockState {
2170 data: BlockStateData {
2171 block: &vanilla_blocks::LEAF_LITTER,
2172 properties: &[("facing", "west"), ("segment_amount", "3")],
2173 },
2174 weight: 1i32,
2175 },
2176 ],
2177 },
2178 tries: 96i32,
2179 radius: 4i32,
2180 height: 2i32,
2181 }),
2182 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
2183 block_state_provider: BlockStateProvider::Weighted {
2184 entries: vec![
2185 WeightedBlockState {
2186 data: BlockStateData {
2187 block: &vanilla_blocks::LEAF_LITTER,
2188 properties: &[("facing", "north"), ("segment_amount", "1")],
2189 },
2190 weight: 1i32,
2191 },
2192 WeightedBlockState {
2193 data: BlockStateData {
2194 block: &vanilla_blocks::LEAF_LITTER,
2195 properties: &[("facing", "east"), ("segment_amount", "1")],
2196 },
2197 weight: 1i32,
2198 },
2199 WeightedBlockState {
2200 data: BlockStateData {
2201 block: &vanilla_blocks::LEAF_LITTER,
2202 properties: &[("facing", "south"), ("segment_amount", "1")],
2203 },
2204 weight: 1i32,
2205 },
2206 WeightedBlockState {
2207 data: BlockStateData {
2208 block: &vanilla_blocks::LEAF_LITTER,
2209 properties: &[("facing", "west"), ("segment_amount", "1")],
2210 },
2211 weight: 1i32,
2212 },
2213 WeightedBlockState {
2214 data: BlockStateData {
2215 block: &vanilla_blocks::LEAF_LITTER,
2216 properties: &[("facing", "north"), ("segment_amount", "2")],
2217 },
2218 weight: 1i32,
2219 },
2220 WeightedBlockState {
2221 data: BlockStateData {
2222 block: &vanilla_blocks::LEAF_LITTER,
2223 properties: &[("facing", "east"), ("segment_amount", "2")],
2224 },
2225 weight: 1i32,
2226 },
2227 WeightedBlockState {
2228 data: BlockStateData {
2229 block: &vanilla_blocks::LEAF_LITTER,
2230 properties: &[("facing", "south"), ("segment_amount", "2")],
2231 },
2232 weight: 1i32,
2233 },
2234 WeightedBlockState {
2235 data: BlockStateData {
2236 block: &vanilla_blocks::LEAF_LITTER,
2237 properties: &[("facing", "west"), ("segment_amount", "2")],
2238 },
2239 weight: 1i32,
2240 },
2241 WeightedBlockState {
2242 data: BlockStateData {
2243 block: &vanilla_blocks::LEAF_LITTER,
2244 properties: &[("facing", "north"), ("segment_amount", "3")],
2245 },
2246 weight: 1i32,
2247 },
2248 WeightedBlockState {
2249 data: BlockStateData {
2250 block: &vanilla_blocks::LEAF_LITTER,
2251 properties: &[("facing", "east"), ("segment_amount", "3")],
2252 },
2253 weight: 1i32,
2254 },
2255 WeightedBlockState {
2256 data: BlockStateData {
2257 block: &vanilla_blocks::LEAF_LITTER,
2258 properties: &[("facing", "south"), ("segment_amount", "3")],
2259 },
2260 weight: 1i32,
2261 },
2262 WeightedBlockState {
2263 data: BlockStateData {
2264 block: &vanilla_blocks::LEAF_LITTER,
2265 properties: &[("facing", "west"), ("segment_amount", "3")],
2266 },
2267 weight: 1i32,
2268 },
2269 WeightedBlockState {
2270 data: BlockStateData {
2271 block: &vanilla_blocks::LEAF_LITTER,
2272 properties: &[("facing", "north"), ("segment_amount", "4")],
2273 },
2274 weight: 1i32,
2275 },
2276 WeightedBlockState {
2277 data: BlockStateData {
2278 block: &vanilla_blocks::LEAF_LITTER,
2279 properties: &[("facing", "east"), ("segment_amount", "4")],
2280 },
2281 weight: 1i32,
2282 },
2283 WeightedBlockState {
2284 data: BlockStateData {
2285 block: &vanilla_blocks::LEAF_LITTER,
2286 properties: &[("facing", "south"), ("segment_amount", "4")],
2287 },
2288 weight: 1i32,
2289 },
2290 WeightedBlockState {
2291 data: BlockStateData {
2292 block: &vanilla_blocks::LEAF_LITTER,
2293 properties: &[("facing", "west"), ("segment_amount", "4")],
2294 },
2295 weight: 1i32,
2296 },
2297 ],
2298 },
2299 tries: 150i32,
2300 radius: 2i32,
2301 height: 2i32,
2302 }),
2303 ],
2304 root_placer: None,
2305 ignore_vines: true,
2306 }),
2307 id: OnceLock::new(),
2308 });
2309pub static DEAD_BUSH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2310 key: Identifier::vanilla_static("dead_bush"),
2311 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
2312 to_place: BlockStateProvider::Simple {
2313 state: BlockStateData {
2314 block: &vanilla_blocks::DEAD_BUSH,
2315 properties: &[],
2316 },
2317 },
2318 schedule_tick: false,
2319 }),
2320 id: OnceLock::new(),
2321});
2322pub static DELTA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2323 key: Identifier::vanilla_static("delta"),
2324 kind: ConfiguredFeatureKind::DeltaFeature(DeltaFeatureConfiguration {
2325 contents: BlockStateData {
2326 block: &vanilla_blocks::LAVA,
2327 properties: &[("level", "0")],
2328 },
2329 rim: BlockStateData {
2330 block: &vanilla_blocks::MAGMA_BLOCK,
2331 properties: &[],
2332 },
2333 size: IntProvider::Uniform {
2334 min_inclusive: 3i32,
2335 max_inclusive: 7i32,
2336 },
2337 rim_size: IntProvider::Uniform {
2338 min_inclusive: 0i32,
2339 max_inclusive: 2i32,
2340 },
2341 }),
2342 id: OnceLock::new(),
2343});
2344pub static DESERT_WELL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2345 key: Identifier::vanilla_static("desert_well"),
2346 kind: ConfiguredFeatureKind::DesertWell,
2347 id: OnceLock::new(),
2348});
2349pub static DISK_CLAY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2350 key: Identifier::vanilla_static("disk_clay"),
2351 kind: ConfiguredFeatureKind::Disk(DiskConfiguration {
2352 state_provider: BlockStateProvider::Simple {
2353 state: BlockStateData {
2354 block: &vanilla_blocks::CLAY,
2355 properties: &[],
2356 },
2357 },
2358 target: BlockPredicate::MatchingBlocks {
2359 blocks: BlockRefList(vec![&vanilla_blocks::DIRT, &vanilla_blocks::CLAY]),
2360 offset: [0i32, 0i32, 0i32],
2361 },
2362 radius: IntProvider::Uniform {
2363 min_inclusive: 2i32,
2364 max_inclusive: 3i32,
2365 },
2366 half_height: 1i32,
2367 }),
2368 id: OnceLock::new(),
2369});
2370pub static DISK_GRASS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2371 key: Identifier::vanilla_static("disk_grass"),
2372 kind: ConfiguredFeatureKind::Disk(DiskConfiguration {
2373 state_provider: BlockStateProvider::RuleBased {
2374 fallback: Some(Box::new(BlockStateProvider::Simple {
2375 state: BlockStateData {
2376 block: &vanilla_blocks::DIRT,
2377 properties: &[],
2378 },
2379 })),
2380 rules: vec![RuleBasedStateProviderRule {
2381 if_true: BlockPredicate::Not {
2382 predicate: Box::new(BlockPredicate::AnyOf {
2383 predicates: vec![
2384 BlockPredicate::Solid {
2385 offset: [0i32, 1i32, 0i32],
2386 },
2387 BlockPredicate::MatchingFluids {
2388 fluids: FluidRefList(vec![&vanilla_fluids::WATER]),
2389 offset: [0i32, 1i32, 0i32],
2390 },
2391 ],
2392 }),
2393 },
2394 then: BlockStateProvider::Simple {
2395 state: BlockStateData {
2396 block: &vanilla_blocks::GRASS_BLOCK,
2397 properties: &[("snowy", "false")],
2398 },
2399 },
2400 }],
2401 },
2402 target: BlockPredicate::MatchingBlocks {
2403 blocks: BlockRefList(vec![&vanilla_blocks::DIRT, &vanilla_blocks::MUD]),
2404 offset: [0i32, 0i32, 0i32],
2405 },
2406 radius: IntProvider::Uniform {
2407 min_inclusive: 2i32,
2408 max_inclusive: 6i32,
2409 },
2410 half_height: 2i32,
2411 }),
2412 id: OnceLock::new(),
2413});
2414pub static DISK_GRAVEL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2415 key: Identifier::vanilla_static("disk_gravel"),
2416 kind: ConfiguredFeatureKind::Disk(DiskConfiguration {
2417 state_provider: BlockStateProvider::Simple {
2418 state: BlockStateData {
2419 block: &vanilla_blocks::GRAVEL,
2420 properties: &[],
2421 },
2422 },
2423 target: BlockPredicate::MatchingBlocks {
2424 blocks: BlockRefList(vec![&vanilla_blocks::DIRT, &vanilla_blocks::GRASS_BLOCK]),
2425 offset: [0i32, 0i32, 0i32],
2426 },
2427 radius: IntProvider::Uniform {
2428 min_inclusive: 2i32,
2429 max_inclusive: 5i32,
2430 },
2431 half_height: 2i32,
2432 }),
2433 id: OnceLock::new(),
2434});
2435pub static DISK_SAND: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2436 key: Identifier::vanilla_static("disk_sand"),
2437 kind: ConfiguredFeatureKind::Disk(DiskConfiguration {
2438 state_provider: BlockStateProvider::RuleBased {
2439 fallback: Some(Box::new(BlockStateProvider::Simple {
2440 state: BlockStateData {
2441 block: &vanilla_blocks::SAND,
2442 properties: &[],
2443 },
2444 })),
2445 rules: vec![RuleBasedStateProviderRule {
2446 if_true: BlockPredicate::MatchingBlocks {
2447 blocks: BlockRefList(vec![&vanilla_blocks::AIR]),
2448 offset: [0i32, -1i32, 0i32],
2449 },
2450 then: BlockStateProvider::Simple {
2451 state: BlockStateData {
2452 block: &vanilla_blocks::SANDSTONE,
2453 properties: &[],
2454 },
2455 },
2456 }],
2457 },
2458 target: BlockPredicate::MatchingBlocks {
2459 blocks: BlockRefList(vec![&vanilla_blocks::DIRT, &vanilla_blocks::GRASS_BLOCK]),
2460 offset: [0i32, 0i32, 0i32],
2461 },
2462 radius: IntProvider::Uniform {
2463 min_inclusive: 2i32,
2464 max_inclusive: 6i32,
2465 },
2466 half_height: 2i32,
2467 }),
2468 id: OnceLock::new(),
2469});
2470pub static DRIPLEAF: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2471 key: Identifier::vanilla_static("dripleaf"),
2472 kind: ConfiguredFeatureKind::SimpleRandomSelector(SimpleRandomSelectorConfiguration {
2473 features: vec![
2474 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
2475 feature: ConfiguredFeatureRef::Inline(Box::new(
2476 ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
2477 to_place: BlockStateProvider::Weighted {
2478 entries: vec![
2479 WeightedBlockState {
2480 data: BlockStateData {
2481 block: &vanilla_blocks::SMALL_DRIPLEAF,
2482 properties: &[
2483 ("facing", "east"),
2484 ("half", "lower"),
2485 ("waterlogged", "false"),
2486 ],
2487 },
2488 weight: 1i32,
2489 },
2490 WeightedBlockState {
2491 data: BlockStateData {
2492 block: &vanilla_blocks::SMALL_DRIPLEAF,
2493 properties: &[
2494 ("facing", "west"),
2495 ("half", "lower"),
2496 ("waterlogged", "false"),
2497 ],
2498 },
2499 weight: 1i32,
2500 },
2501 WeightedBlockState {
2502 data: BlockStateData {
2503 block: &vanilla_blocks::SMALL_DRIPLEAF,
2504 properties: &[
2505 ("facing", "north"),
2506 ("half", "lower"),
2507 ("waterlogged", "false"),
2508 ],
2509 },
2510 weight: 1i32,
2511 },
2512 WeightedBlockState {
2513 data: BlockStateData {
2514 block: &vanilla_blocks::SMALL_DRIPLEAF,
2515 properties: &[
2516 ("facing", "south"),
2517 ("half", "lower"),
2518 ("waterlogged", "false"),
2519 ],
2520 },
2521 weight: 1i32,
2522 },
2523 ],
2524 },
2525 schedule_tick: false,
2526 }),
2527 )),
2528 placement: vec![],
2529 })),
2530 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
2531 feature: ConfiguredFeatureRef::Inline(Box::new(
2532 ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
2533 direction: Direction::Up,
2534 allowed_placement: BlockPredicate::AnyOf {
2535 predicates: vec![
2536 BlockPredicate::MatchingBlockTag {
2537 tag: Identifier::vanilla_static("air"),
2538 offset: [0i32, 0i32, 0i32],
2539 },
2540 BlockPredicate::MatchingBlocks {
2541 blocks: BlockRefList(vec![&vanilla_blocks::WATER]),
2542 offset: [0i32, 0i32, 0i32],
2543 },
2544 ],
2545 },
2546 layers: vec![
2547 BlockColumnLayer {
2548 height: IntProvider::WeightedList {
2549 distribution: vec![
2550 WeightedIntProvider {
2551 data: IntProvider::Uniform {
2552 min_inclusive: 0i32,
2553 max_inclusive: 4i32,
2554 },
2555 weight: 2i32,
2556 },
2557 WeightedIntProvider {
2558 data: IntProvider::Constant(0i32),
2559 weight: 1i32,
2560 },
2561 ],
2562 },
2563 provider: BlockStateProvider::Simple {
2564 state: BlockStateData {
2565 block: &vanilla_blocks::BIG_DRIPLEAF_STEM,
2566 properties: &[("facing", "east"), ("waterlogged", "false")],
2567 },
2568 },
2569 },
2570 BlockColumnLayer {
2571 height: IntProvider::Constant(1i32),
2572 provider: BlockStateProvider::Simple {
2573 state: BlockStateData {
2574 block: &vanilla_blocks::BIG_DRIPLEAF,
2575 properties: &[
2576 ("facing", "east"),
2577 ("tilt", "none"),
2578 ("waterlogged", "false"),
2579 ],
2580 },
2581 },
2582 },
2583 ],
2584 prioritize_tip: true,
2585 }),
2586 )),
2587 placement: vec![],
2588 })),
2589 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
2590 feature: ConfiguredFeatureRef::Inline(Box::new(
2591 ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
2592 direction: Direction::Up,
2593 allowed_placement: BlockPredicate::AnyOf {
2594 predicates: vec![
2595 BlockPredicate::MatchingBlockTag {
2596 tag: Identifier::vanilla_static("air"),
2597 offset: [0i32, 0i32, 0i32],
2598 },
2599 BlockPredicate::MatchingBlocks {
2600 blocks: BlockRefList(vec![&vanilla_blocks::WATER]),
2601 offset: [0i32, 0i32, 0i32],
2602 },
2603 ],
2604 },
2605 layers: vec![
2606 BlockColumnLayer {
2607 height: IntProvider::WeightedList {
2608 distribution: vec![
2609 WeightedIntProvider {
2610 data: IntProvider::Uniform {
2611 min_inclusive: 0i32,
2612 max_inclusive: 4i32,
2613 },
2614 weight: 2i32,
2615 },
2616 WeightedIntProvider {
2617 data: IntProvider::Constant(0i32),
2618 weight: 1i32,
2619 },
2620 ],
2621 },
2622 provider: BlockStateProvider::Simple {
2623 state: BlockStateData {
2624 block: &vanilla_blocks::BIG_DRIPLEAF_STEM,
2625 properties: &[("facing", "west"), ("waterlogged", "false")],
2626 },
2627 },
2628 },
2629 BlockColumnLayer {
2630 height: IntProvider::Constant(1i32),
2631 provider: BlockStateProvider::Simple {
2632 state: BlockStateData {
2633 block: &vanilla_blocks::BIG_DRIPLEAF,
2634 properties: &[
2635 ("facing", "west"),
2636 ("tilt", "none"),
2637 ("waterlogged", "false"),
2638 ],
2639 },
2640 },
2641 },
2642 ],
2643 prioritize_tip: true,
2644 }),
2645 )),
2646 placement: vec![],
2647 })),
2648 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
2649 feature: ConfiguredFeatureRef::Inline(Box::new(
2650 ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
2651 direction: Direction::Up,
2652 allowed_placement: BlockPredicate::AnyOf {
2653 predicates: vec![
2654 BlockPredicate::MatchingBlockTag {
2655 tag: Identifier::vanilla_static("air"),
2656 offset: [0i32, 0i32, 0i32],
2657 },
2658 BlockPredicate::MatchingBlocks {
2659 blocks: BlockRefList(vec![&vanilla_blocks::WATER]),
2660 offset: [0i32, 0i32, 0i32],
2661 },
2662 ],
2663 },
2664 layers: vec![
2665 BlockColumnLayer {
2666 height: IntProvider::WeightedList {
2667 distribution: vec![
2668 WeightedIntProvider {
2669 data: IntProvider::Uniform {
2670 min_inclusive: 0i32,
2671 max_inclusive: 4i32,
2672 },
2673 weight: 2i32,
2674 },
2675 WeightedIntProvider {
2676 data: IntProvider::Constant(0i32),
2677 weight: 1i32,
2678 },
2679 ],
2680 },
2681 provider: BlockStateProvider::Simple {
2682 state: BlockStateData {
2683 block: &vanilla_blocks::BIG_DRIPLEAF_STEM,
2684 properties: &[
2685 ("facing", "south"),
2686 ("waterlogged", "false"),
2687 ],
2688 },
2689 },
2690 },
2691 BlockColumnLayer {
2692 height: IntProvider::Constant(1i32),
2693 provider: BlockStateProvider::Simple {
2694 state: BlockStateData {
2695 block: &vanilla_blocks::BIG_DRIPLEAF,
2696 properties: &[
2697 ("facing", "south"),
2698 ("tilt", "none"),
2699 ("waterlogged", "false"),
2700 ],
2701 },
2702 },
2703 },
2704 ],
2705 prioritize_tip: true,
2706 }),
2707 )),
2708 placement: vec![],
2709 })),
2710 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
2711 feature: ConfiguredFeatureRef::Inline(Box::new(
2712 ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
2713 direction: Direction::Up,
2714 allowed_placement: BlockPredicate::AnyOf {
2715 predicates: vec![
2716 BlockPredicate::MatchingBlockTag {
2717 tag: Identifier::vanilla_static("air"),
2718 offset: [0i32, 0i32, 0i32],
2719 },
2720 BlockPredicate::MatchingBlocks {
2721 blocks: BlockRefList(vec![&vanilla_blocks::WATER]),
2722 offset: [0i32, 0i32, 0i32],
2723 },
2724 ],
2725 },
2726 layers: vec![
2727 BlockColumnLayer {
2728 height: IntProvider::WeightedList {
2729 distribution: vec![
2730 WeightedIntProvider {
2731 data: IntProvider::Uniform {
2732 min_inclusive: 0i32,
2733 max_inclusive: 4i32,
2734 },
2735 weight: 2i32,
2736 },
2737 WeightedIntProvider {
2738 data: IntProvider::Constant(0i32),
2739 weight: 1i32,
2740 },
2741 ],
2742 },
2743 provider: BlockStateProvider::Simple {
2744 state: BlockStateData {
2745 block: &vanilla_blocks::BIG_DRIPLEAF_STEM,
2746 properties: &[
2747 ("facing", "north"),
2748 ("waterlogged", "false"),
2749 ],
2750 },
2751 },
2752 },
2753 BlockColumnLayer {
2754 height: IntProvider::Constant(1i32),
2755 provider: BlockStateProvider::Simple {
2756 state: BlockStateData {
2757 block: &vanilla_blocks::BIG_DRIPLEAF,
2758 properties: &[
2759 ("facing", "north"),
2760 ("tilt", "none"),
2761 ("waterlogged", "false"),
2762 ],
2763 },
2764 },
2765 },
2766 ],
2767 prioritize_tip: true,
2768 }),
2769 )),
2770 placement: vec![],
2771 })),
2772 ],
2773 }),
2774 id: OnceLock::new(),
2775});
2776pub static DRIPSTONE_CLUSTER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2777 key: Identifier::vanilla_static("dripstone_cluster"),
2778 kind: ConfiguredFeatureKind::DripstoneCluster(DripstoneClusterConfiguration {
2779 floor_to_ceiling_search_range: 12i32,
2780 height: IntProvider::Uniform {
2781 min_inclusive: 3i32,
2782 max_inclusive: 6i32,
2783 },
2784 radius: IntProvider::Uniform {
2785 min_inclusive: 2i32,
2786 max_inclusive: 8i32,
2787 },
2788 max_stalagmite_stalactite_height_diff: 1i32,
2789 height_deviation: 3i32,
2790 dripstone_block_layer_thickness: IntProvider::Uniform {
2791 min_inclusive: 2i32,
2792 max_inclusive: 4i32,
2793 },
2794 density: FloatProvider::Uniform {
2795 min_inclusive: 0.3f32,
2796 max_exclusive: 0.7f32,
2797 },
2798 wetness: FloatProvider::ClampedNormal {
2799 mean: 0.1f32,
2800 deviation: 0.3f32,
2801 min: 0.1f32,
2802 max: 0.9f32,
2803 },
2804 chance_of_dripstone_column_at_max_distance_from_center: 0.1f32,
2805 max_distance_from_center_affecting_height_bias: 8i32,
2806 max_distance_from_edge_affecting_chance_of_dripstone_column: 3i32,
2807 }),
2808 id: OnceLock::new(),
2809});
2810pub static DRY_GRASS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2811 key: Identifier::vanilla_static("dry_grass"),
2812 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
2813 to_place: BlockStateProvider::Weighted {
2814 entries: vec![
2815 WeightedBlockState {
2816 data: BlockStateData {
2817 block: &vanilla_blocks::SHORT_DRY_GRASS,
2818 properties: &[],
2819 },
2820 weight: 1i32,
2821 },
2822 WeightedBlockState {
2823 data: BlockStateData {
2824 block: &vanilla_blocks::TALL_DRY_GRASS,
2825 properties: &[],
2826 },
2827 weight: 1i32,
2828 },
2829 ],
2830 },
2831 schedule_tick: false,
2832 }),
2833 id: OnceLock::new(),
2834});
2835pub static END_GATEWAY_DELAYED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2836 key: Identifier::vanilla_static("end_gateway_delayed"),
2837 kind: ConfiguredFeatureKind::EndGateway(EndGatewayConfiguration {
2838 exit: None,
2839 exact: false,
2840 }),
2841 id: OnceLock::new(),
2842});
2843pub static END_GATEWAY_RETURN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2844 key: Identifier::vanilla_static("end_gateway_return"),
2845 kind: ConfiguredFeatureKind::EndGateway(EndGatewayConfiguration {
2846 exit: Some([100i32, 50i32, 0i32]),
2847 exact: true,
2848 }),
2849 id: OnceLock::new(),
2850});
2851pub static END_ISLAND: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2852 key: Identifier::vanilla_static("end_island"),
2853 kind: ConfiguredFeatureKind::EndIsland,
2854 id: OnceLock::new(),
2855});
2856pub static END_PLATFORM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2857 key: Identifier::vanilla_static("end_platform"),
2858 kind: ConfiguredFeatureKind::EndPlatform,
2859 id: OnceLock::new(),
2860});
2861pub static END_SPIKE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2862 key: Identifier::vanilla_static("end_spike"),
2863 kind: ConfiguredFeatureKind::EndSpike(EndSpikeConfiguration {
2864 spikes: vec![],
2865 crystal_invulnerable: false,
2866 crystal_beam_target: None,
2867 }),
2868 id: OnceLock::new(),
2869});
2870pub static FALLEN_BIRCH_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2871 key: Identifier::vanilla_static("fallen_birch_tree"),
2872 kind: ConfiguredFeatureKind::FallenTree(FallenTreeConfiguration {
2873 trunk_provider: BlockStateProvider::Simple {
2874 state: BlockStateData {
2875 block: &vanilla_blocks::BIRCH_LOG,
2876 properties: &[("axis", "y")],
2877 },
2878 },
2879 log_length: IntProvider::Uniform {
2880 min_inclusive: 5i32,
2881 max_inclusive: 8i32,
2882 },
2883 stump_decorators: vec![],
2884 log_decorators: vec![TreeDecorator::AttachedToLogs(AttachedToLogsDecorator {
2885 probability: 0.1f32,
2886 block_provider: BlockStateProvider::Weighted {
2887 entries: vec![
2888 WeightedBlockState {
2889 data: BlockStateData {
2890 block: &vanilla_blocks::RED_MUSHROOM,
2891 properties: &[],
2892 },
2893 weight: 2i32,
2894 },
2895 WeightedBlockState {
2896 data: BlockStateData {
2897 block: &vanilla_blocks::BROWN_MUSHROOM,
2898 properties: &[],
2899 },
2900 weight: 1i32,
2901 },
2902 ],
2903 },
2904 directions: vec![Direction::Up],
2905 })],
2906 }),
2907 id: OnceLock::new(),
2908});
2909pub static FALLEN_JUNGLE_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2910 key: Identifier::vanilla_static("fallen_jungle_tree"),
2911 kind: ConfiguredFeatureKind::FallenTree(FallenTreeConfiguration {
2912 trunk_provider: BlockStateProvider::Simple {
2913 state: BlockStateData {
2914 block: &vanilla_blocks::JUNGLE_LOG,
2915 properties: &[("axis", "y")],
2916 },
2917 },
2918 log_length: IntProvider::Uniform {
2919 min_inclusive: 4i32,
2920 max_inclusive: 11i32,
2921 },
2922 stump_decorators: vec![TreeDecorator::TrunkVine],
2923 log_decorators: vec![TreeDecorator::AttachedToLogs(AttachedToLogsDecorator {
2924 probability: 0.1f32,
2925 block_provider: BlockStateProvider::Weighted {
2926 entries: vec![
2927 WeightedBlockState {
2928 data: BlockStateData {
2929 block: &vanilla_blocks::RED_MUSHROOM,
2930 properties: &[],
2931 },
2932 weight: 2i32,
2933 },
2934 WeightedBlockState {
2935 data: BlockStateData {
2936 block: &vanilla_blocks::BROWN_MUSHROOM,
2937 properties: &[],
2938 },
2939 weight: 1i32,
2940 },
2941 ],
2942 },
2943 directions: vec![Direction::Up],
2944 })],
2945 }),
2946 id: OnceLock::new(),
2947});
2948pub static FALLEN_OAK_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2949 key: Identifier::vanilla_static("fallen_oak_tree"),
2950 kind: ConfiguredFeatureKind::FallenTree(FallenTreeConfiguration {
2951 trunk_provider: BlockStateProvider::Simple {
2952 state: BlockStateData {
2953 block: &vanilla_blocks::OAK_LOG,
2954 properties: &[("axis", "y")],
2955 },
2956 },
2957 log_length: IntProvider::Uniform {
2958 min_inclusive: 4i32,
2959 max_inclusive: 7i32,
2960 },
2961 stump_decorators: vec![TreeDecorator::TrunkVine],
2962 log_decorators: vec![TreeDecorator::AttachedToLogs(AttachedToLogsDecorator {
2963 probability: 0.1f32,
2964 block_provider: BlockStateProvider::Weighted {
2965 entries: vec![
2966 WeightedBlockState {
2967 data: BlockStateData {
2968 block: &vanilla_blocks::RED_MUSHROOM,
2969 properties: &[],
2970 },
2971 weight: 2i32,
2972 },
2973 WeightedBlockState {
2974 data: BlockStateData {
2975 block: &vanilla_blocks::BROWN_MUSHROOM,
2976 properties: &[],
2977 },
2978 weight: 1i32,
2979 },
2980 ],
2981 },
2982 directions: vec![Direction::Up],
2983 })],
2984 }),
2985 id: OnceLock::new(),
2986});
2987pub static FALLEN_SPRUCE_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
2988 key: Identifier::vanilla_static("fallen_spruce_tree"),
2989 kind: ConfiguredFeatureKind::FallenTree(FallenTreeConfiguration {
2990 trunk_provider: BlockStateProvider::Simple {
2991 state: BlockStateData {
2992 block: &vanilla_blocks::SPRUCE_LOG,
2993 properties: &[("axis", "y")],
2994 },
2995 },
2996 log_length: IntProvider::Uniform {
2997 min_inclusive: 6i32,
2998 max_inclusive: 10i32,
2999 },
3000 stump_decorators: vec![],
3001 log_decorators: vec![TreeDecorator::AttachedToLogs(AttachedToLogsDecorator {
3002 probability: 0.1f32,
3003 block_provider: BlockStateProvider::Weighted {
3004 entries: vec![
3005 WeightedBlockState {
3006 data: BlockStateData {
3007 block: &vanilla_blocks::RED_MUSHROOM,
3008 properties: &[],
3009 },
3010 weight: 2i32,
3011 },
3012 WeightedBlockState {
3013 data: BlockStateData {
3014 block: &vanilla_blocks::BROWN_MUSHROOM,
3015 properties: &[],
3016 },
3017 weight: 1i32,
3018 },
3019 ],
3020 },
3021 directions: vec![Direction::Up],
3022 })],
3023 }),
3024 id: OnceLock::new(),
3025});
3026pub static FALLEN_SUPER_BIRCH_TREE: LazyLock<ConfiguredFeature> =
3027 LazyLock::new(|| ConfiguredFeature {
3028 key: Identifier::vanilla_static("fallen_super_birch_tree"),
3029 kind: ConfiguredFeatureKind::FallenTree(FallenTreeConfiguration {
3030 trunk_provider: BlockStateProvider::Simple {
3031 state: BlockStateData {
3032 block: &vanilla_blocks::BIRCH_LOG,
3033 properties: &[("axis", "y")],
3034 },
3035 },
3036 log_length: IntProvider::Uniform {
3037 min_inclusive: 5i32,
3038 max_inclusive: 15i32,
3039 },
3040 stump_decorators: vec![],
3041 log_decorators: vec![TreeDecorator::AttachedToLogs(AttachedToLogsDecorator {
3042 probability: 0.1f32,
3043 block_provider: BlockStateProvider::Weighted {
3044 entries: vec![
3045 WeightedBlockState {
3046 data: BlockStateData {
3047 block: &vanilla_blocks::RED_MUSHROOM,
3048 properties: &[],
3049 },
3050 weight: 2i32,
3051 },
3052 WeightedBlockState {
3053 data: BlockStateData {
3054 block: &vanilla_blocks::BROWN_MUSHROOM,
3055 properties: &[],
3056 },
3057 weight: 1i32,
3058 },
3059 ],
3060 },
3061 directions: vec![Direction::Up],
3062 })],
3063 }),
3064 id: OnceLock::new(),
3065 });
3066pub static FANCY_OAK: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3067 key: Identifier::vanilla_static("fancy_oak"),
3068 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
3069 trunk_provider: BlockStateProvider::Simple {
3070 state: BlockStateData {
3071 block: &vanilla_blocks::OAK_LOG,
3072 properties: &[("axis", "y")],
3073 },
3074 },
3075 below_trunk_provider: BlockStateProvider::RuleBased {
3076 fallback: None,
3077 rules: vec![RuleBasedStateProviderRule {
3078 if_true: BlockPredicate::Not {
3079 predicate: Box::new(BlockPredicate::MatchingBlockTag {
3080 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
3081 offset: [0i32, 0i32, 0i32],
3082 }),
3083 },
3084 then: BlockStateProvider::Simple {
3085 state: BlockStateData {
3086 block: &vanilla_blocks::DIRT,
3087 properties: &[],
3088 },
3089 },
3090 }],
3091 },
3092 foliage_provider: BlockStateProvider::Simple {
3093 state: BlockStateData {
3094 block: &vanilla_blocks::OAK_LEAVES,
3095 properties: &[
3096 ("distance", "7"),
3097 ("persistent", "false"),
3098 ("waterlogged", "false"),
3099 ],
3100 },
3101 },
3102 trunk_placer: TrunkPlacer::Fancy(TrunkPlacerBase {
3103 base_height: 3i32,
3104 height_rand_a: 11i32,
3105 height_rand_b: 0i32,
3106 }),
3107 foliage_placer: FoliagePlacer::Fancy(BlobFoliagePlacer {
3108 radius: IntProvider::Constant(2i32),
3109 offset: IntProvider::Constant(4i32),
3110 height: IntProvider::Constant(4i32),
3111 }),
3112 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
3113 limit: 0i32,
3114 lower_size: 0i32,
3115 upper_size: 0i32,
3116 min_clipped_height: Some(4i32),
3117 }),
3118 decorators: vec![],
3119 root_placer: None,
3120 ignore_vines: true,
3121 }),
3122 id: OnceLock::new(),
3123});
3124pub static FANCY_OAK_BEES: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3125 key: Identifier::vanilla_static("fancy_oak_bees"),
3126 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
3127 trunk_provider: BlockStateProvider::Simple {
3128 state: BlockStateData {
3129 block: &vanilla_blocks::OAK_LOG,
3130 properties: &[("axis", "y")],
3131 },
3132 },
3133 below_trunk_provider: BlockStateProvider::RuleBased {
3134 fallback: None,
3135 rules: vec![RuleBasedStateProviderRule {
3136 if_true: BlockPredicate::Not {
3137 predicate: Box::new(BlockPredicate::MatchingBlockTag {
3138 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
3139 offset: [0i32, 0i32, 0i32],
3140 }),
3141 },
3142 then: BlockStateProvider::Simple {
3143 state: BlockStateData {
3144 block: &vanilla_blocks::DIRT,
3145 properties: &[],
3146 },
3147 },
3148 }],
3149 },
3150 foliage_provider: BlockStateProvider::Simple {
3151 state: BlockStateData {
3152 block: &vanilla_blocks::OAK_LEAVES,
3153 properties: &[
3154 ("distance", "7"),
3155 ("persistent", "false"),
3156 ("waterlogged", "false"),
3157 ],
3158 },
3159 },
3160 trunk_placer: TrunkPlacer::Fancy(TrunkPlacerBase {
3161 base_height: 3i32,
3162 height_rand_a: 11i32,
3163 height_rand_b: 0i32,
3164 }),
3165 foliage_placer: FoliagePlacer::Fancy(BlobFoliagePlacer {
3166 radius: IntProvider::Constant(2i32),
3167 offset: IntProvider::Constant(4i32),
3168 height: IntProvider::Constant(4i32),
3169 }),
3170 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
3171 limit: 0i32,
3172 lower_size: 0i32,
3173 upper_size: 0i32,
3174 min_clipped_height: Some(4i32),
3175 }),
3176 decorators: vec![TreeDecorator::Beehive { probability: 1f32 }],
3177 root_placer: None,
3178 ignore_vines: true,
3179 }),
3180 id: OnceLock::new(),
3181});
3182pub static FANCY_OAK_BEES_0002_LEAF_LITTER: LazyLock<ConfiguredFeature> =
3183 LazyLock::new(|| ConfiguredFeature {
3184 key: Identifier::vanilla_static("fancy_oak_bees_0002_leaf_litter"),
3185 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
3186 trunk_provider: BlockStateProvider::Simple {
3187 state: BlockStateData {
3188 block: &vanilla_blocks::OAK_LOG,
3189 properties: &[("axis", "y")],
3190 },
3191 },
3192 below_trunk_provider: BlockStateProvider::RuleBased {
3193 fallback: None,
3194 rules: vec![RuleBasedStateProviderRule {
3195 if_true: BlockPredicate::Not {
3196 predicate: Box::new(BlockPredicate::MatchingBlockTag {
3197 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
3198 offset: [0i32, 0i32, 0i32],
3199 }),
3200 },
3201 then: BlockStateProvider::Simple {
3202 state: BlockStateData {
3203 block: &vanilla_blocks::DIRT,
3204 properties: &[],
3205 },
3206 },
3207 }],
3208 },
3209 foliage_provider: BlockStateProvider::Simple {
3210 state: BlockStateData {
3211 block: &vanilla_blocks::OAK_LEAVES,
3212 properties: &[
3213 ("distance", "7"),
3214 ("persistent", "false"),
3215 ("waterlogged", "false"),
3216 ],
3217 },
3218 },
3219 trunk_placer: TrunkPlacer::Fancy(TrunkPlacerBase {
3220 base_height: 3i32,
3221 height_rand_a: 11i32,
3222 height_rand_b: 0i32,
3223 }),
3224 foliage_placer: FoliagePlacer::Fancy(BlobFoliagePlacer {
3225 radius: IntProvider::Constant(2i32),
3226 offset: IntProvider::Constant(4i32),
3227 height: IntProvider::Constant(4i32),
3228 }),
3229 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
3230 limit: 0i32,
3231 lower_size: 0i32,
3232 upper_size: 0i32,
3233 min_clipped_height: Some(4i32),
3234 }),
3235 decorators: vec![
3236 TreeDecorator::Beehive {
3237 probability: 0.002f32,
3238 },
3239 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
3240 block_state_provider: BlockStateProvider::Weighted {
3241 entries: vec![
3242 WeightedBlockState {
3243 data: BlockStateData {
3244 block: &vanilla_blocks::LEAF_LITTER,
3245 properties: &[("facing", "north"), ("segment_amount", "1")],
3246 },
3247 weight: 1i32,
3248 },
3249 WeightedBlockState {
3250 data: BlockStateData {
3251 block: &vanilla_blocks::LEAF_LITTER,
3252 properties: &[("facing", "east"), ("segment_amount", "1")],
3253 },
3254 weight: 1i32,
3255 },
3256 WeightedBlockState {
3257 data: BlockStateData {
3258 block: &vanilla_blocks::LEAF_LITTER,
3259 properties: &[("facing", "south"), ("segment_amount", "1")],
3260 },
3261 weight: 1i32,
3262 },
3263 WeightedBlockState {
3264 data: BlockStateData {
3265 block: &vanilla_blocks::LEAF_LITTER,
3266 properties: &[("facing", "west"), ("segment_amount", "1")],
3267 },
3268 weight: 1i32,
3269 },
3270 WeightedBlockState {
3271 data: BlockStateData {
3272 block: &vanilla_blocks::LEAF_LITTER,
3273 properties: &[("facing", "north"), ("segment_amount", "2")],
3274 },
3275 weight: 1i32,
3276 },
3277 WeightedBlockState {
3278 data: BlockStateData {
3279 block: &vanilla_blocks::LEAF_LITTER,
3280 properties: &[("facing", "east"), ("segment_amount", "2")],
3281 },
3282 weight: 1i32,
3283 },
3284 WeightedBlockState {
3285 data: BlockStateData {
3286 block: &vanilla_blocks::LEAF_LITTER,
3287 properties: &[("facing", "south"), ("segment_amount", "2")],
3288 },
3289 weight: 1i32,
3290 },
3291 WeightedBlockState {
3292 data: BlockStateData {
3293 block: &vanilla_blocks::LEAF_LITTER,
3294 properties: &[("facing", "west"), ("segment_amount", "2")],
3295 },
3296 weight: 1i32,
3297 },
3298 WeightedBlockState {
3299 data: BlockStateData {
3300 block: &vanilla_blocks::LEAF_LITTER,
3301 properties: &[("facing", "north"), ("segment_amount", "3")],
3302 },
3303 weight: 1i32,
3304 },
3305 WeightedBlockState {
3306 data: BlockStateData {
3307 block: &vanilla_blocks::LEAF_LITTER,
3308 properties: &[("facing", "east"), ("segment_amount", "3")],
3309 },
3310 weight: 1i32,
3311 },
3312 WeightedBlockState {
3313 data: BlockStateData {
3314 block: &vanilla_blocks::LEAF_LITTER,
3315 properties: &[("facing", "south"), ("segment_amount", "3")],
3316 },
3317 weight: 1i32,
3318 },
3319 WeightedBlockState {
3320 data: BlockStateData {
3321 block: &vanilla_blocks::LEAF_LITTER,
3322 properties: &[("facing", "west"), ("segment_amount", "3")],
3323 },
3324 weight: 1i32,
3325 },
3326 ],
3327 },
3328 tries: 96i32,
3329 radius: 4i32,
3330 height: 2i32,
3331 }),
3332 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
3333 block_state_provider: BlockStateProvider::Weighted {
3334 entries: vec![
3335 WeightedBlockState {
3336 data: BlockStateData {
3337 block: &vanilla_blocks::LEAF_LITTER,
3338 properties: &[("facing", "north"), ("segment_amount", "1")],
3339 },
3340 weight: 1i32,
3341 },
3342 WeightedBlockState {
3343 data: BlockStateData {
3344 block: &vanilla_blocks::LEAF_LITTER,
3345 properties: &[("facing", "east"), ("segment_amount", "1")],
3346 },
3347 weight: 1i32,
3348 },
3349 WeightedBlockState {
3350 data: BlockStateData {
3351 block: &vanilla_blocks::LEAF_LITTER,
3352 properties: &[("facing", "south"), ("segment_amount", "1")],
3353 },
3354 weight: 1i32,
3355 },
3356 WeightedBlockState {
3357 data: BlockStateData {
3358 block: &vanilla_blocks::LEAF_LITTER,
3359 properties: &[("facing", "west"), ("segment_amount", "1")],
3360 },
3361 weight: 1i32,
3362 },
3363 WeightedBlockState {
3364 data: BlockStateData {
3365 block: &vanilla_blocks::LEAF_LITTER,
3366 properties: &[("facing", "north"), ("segment_amount", "2")],
3367 },
3368 weight: 1i32,
3369 },
3370 WeightedBlockState {
3371 data: BlockStateData {
3372 block: &vanilla_blocks::LEAF_LITTER,
3373 properties: &[("facing", "east"), ("segment_amount", "2")],
3374 },
3375 weight: 1i32,
3376 },
3377 WeightedBlockState {
3378 data: BlockStateData {
3379 block: &vanilla_blocks::LEAF_LITTER,
3380 properties: &[("facing", "south"), ("segment_amount", "2")],
3381 },
3382 weight: 1i32,
3383 },
3384 WeightedBlockState {
3385 data: BlockStateData {
3386 block: &vanilla_blocks::LEAF_LITTER,
3387 properties: &[("facing", "west"), ("segment_amount", "2")],
3388 },
3389 weight: 1i32,
3390 },
3391 WeightedBlockState {
3392 data: BlockStateData {
3393 block: &vanilla_blocks::LEAF_LITTER,
3394 properties: &[("facing", "north"), ("segment_amount", "3")],
3395 },
3396 weight: 1i32,
3397 },
3398 WeightedBlockState {
3399 data: BlockStateData {
3400 block: &vanilla_blocks::LEAF_LITTER,
3401 properties: &[("facing", "east"), ("segment_amount", "3")],
3402 },
3403 weight: 1i32,
3404 },
3405 WeightedBlockState {
3406 data: BlockStateData {
3407 block: &vanilla_blocks::LEAF_LITTER,
3408 properties: &[("facing", "south"), ("segment_amount", "3")],
3409 },
3410 weight: 1i32,
3411 },
3412 WeightedBlockState {
3413 data: BlockStateData {
3414 block: &vanilla_blocks::LEAF_LITTER,
3415 properties: &[("facing", "west"), ("segment_amount", "3")],
3416 },
3417 weight: 1i32,
3418 },
3419 WeightedBlockState {
3420 data: BlockStateData {
3421 block: &vanilla_blocks::LEAF_LITTER,
3422 properties: &[("facing", "north"), ("segment_amount", "4")],
3423 },
3424 weight: 1i32,
3425 },
3426 WeightedBlockState {
3427 data: BlockStateData {
3428 block: &vanilla_blocks::LEAF_LITTER,
3429 properties: &[("facing", "east"), ("segment_amount", "4")],
3430 },
3431 weight: 1i32,
3432 },
3433 WeightedBlockState {
3434 data: BlockStateData {
3435 block: &vanilla_blocks::LEAF_LITTER,
3436 properties: &[("facing", "south"), ("segment_amount", "4")],
3437 },
3438 weight: 1i32,
3439 },
3440 WeightedBlockState {
3441 data: BlockStateData {
3442 block: &vanilla_blocks::LEAF_LITTER,
3443 properties: &[("facing", "west"), ("segment_amount", "4")],
3444 },
3445 weight: 1i32,
3446 },
3447 ],
3448 },
3449 tries: 150i32,
3450 radius: 2i32,
3451 height: 2i32,
3452 }),
3453 ],
3454 root_placer: None,
3455 ignore_vines: true,
3456 }),
3457 id: OnceLock::new(),
3458 });
3459pub static FANCY_OAK_BEES_002: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3460 key: Identifier::vanilla_static("fancy_oak_bees_002"),
3461 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
3462 trunk_provider: BlockStateProvider::Simple {
3463 state: BlockStateData {
3464 block: &vanilla_blocks::OAK_LOG,
3465 properties: &[("axis", "y")],
3466 },
3467 },
3468 below_trunk_provider: BlockStateProvider::RuleBased {
3469 fallback: None,
3470 rules: vec![RuleBasedStateProviderRule {
3471 if_true: BlockPredicate::Not {
3472 predicate: Box::new(BlockPredicate::MatchingBlockTag {
3473 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
3474 offset: [0i32, 0i32, 0i32],
3475 }),
3476 },
3477 then: BlockStateProvider::Simple {
3478 state: BlockStateData {
3479 block: &vanilla_blocks::DIRT,
3480 properties: &[],
3481 },
3482 },
3483 }],
3484 },
3485 foliage_provider: BlockStateProvider::Simple {
3486 state: BlockStateData {
3487 block: &vanilla_blocks::OAK_LEAVES,
3488 properties: &[
3489 ("distance", "7"),
3490 ("persistent", "false"),
3491 ("waterlogged", "false"),
3492 ],
3493 },
3494 },
3495 trunk_placer: TrunkPlacer::Fancy(TrunkPlacerBase {
3496 base_height: 3i32,
3497 height_rand_a: 11i32,
3498 height_rand_b: 0i32,
3499 }),
3500 foliage_placer: FoliagePlacer::Fancy(BlobFoliagePlacer {
3501 radius: IntProvider::Constant(2i32),
3502 offset: IntProvider::Constant(4i32),
3503 height: IntProvider::Constant(4i32),
3504 }),
3505 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
3506 limit: 0i32,
3507 lower_size: 0i32,
3508 upper_size: 0i32,
3509 min_clipped_height: Some(4i32),
3510 }),
3511 decorators: vec![TreeDecorator::Beehive {
3512 probability: 0.02f32,
3513 }],
3514 root_placer: None,
3515 ignore_vines: true,
3516 }),
3517 id: OnceLock::new(),
3518});
3519pub static FANCY_OAK_BEES_005: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3520 key: Identifier::vanilla_static("fancy_oak_bees_005"),
3521 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
3522 trunk_provider: BlockStateProvider::Simple {
3523 state: BlockStateData {
3524 block: &vanilla_blocks::OAK_LOG,
3525 properties: &[("axis", "y")],
3526 },
3527 },
3528 below_trunk_provider: BlockStateProvider::RuleBased {
3529 fallback: None,
3530 rules: vec![RuleBasedStateProviderRule {
3531 if_true: BlockPredicate::Not {
3532 predicate: Box::new(BlockPredicate::MatchingBlockTag {
3533 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
3534 offset: [0i32, 0i32, 0i32],
3535 }),
3536 },
3537 then: BlockStateProvider::Simple {
3538 state: BlockStateData {
3539 block: &vanilla_blocks::DIRT,
3540 properties: &[],
3541 },
3542 },
3543 }],
3544 },
3545 foliage_provider: BlockStateProvider::Simple {
3546 state: BlockStateData {
3547 block: &vanilla_blocks::OAK_LEAVES,
3548 properties: &[
3549 ("distance", "7"),
3550 ("persistent", "false"),
3551 ("waterlogged", "false"),
3552 ],
3553 },
3554 },
3555 trunk_placer: TrunkPlacer::Fancy(TrunkPlacerBase {
3556 base_height: 3i32,
3557 height_rand_a: 11i32,
3558 height_rand_b: 0i32,
3559 }),
3560 foliage_placer: FoliagePlacer::Fancy(BlobFoliagePlacer {
3561 radius: IntProvider::Constant(2i32),
3562 offset: IntProvider::Constant(4i32),
3563 height: IntProvider::Constant(4i32),
3564 }),
3565 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
3566 limit: 0i32,
3567 lower_size: 0i32,
3568 upper_size: 0i32,
3569 min_clipped_height: Some(4i32),
3570 }),
3571 decorators: vec![TreeDecorator::Beehive {
3572 probability: 0.05f32,
3573 }],
3574 root_placer: None,
3575 ignore_vines: true,
3576 }),
3577 id: OnceLock::new(),
3578});
3579pub static FANCY_OAK_LEAF_LITTER: LazyLock<ConfiguredFeature> =
3580 LazyLock::new(|| ConfiguredFeature {
3581 key: Identifier::vanilla_static("fancy_oak_leaf_litter"),
3582 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
3583 trunk_provider: BlockStateProvider::Simple {
3584 state: BlockStateData {
3585 block: &vanilla_blocks::OAK_LOG,
3586 properties: &[("axis", "y")],
3587 },
3588 },
3589 below_trunk_provider: BlockStateProvider::RuleBased {
3590 fallback: None,
3591 rules: vec![RuleBasedStateProviderRule {
3592 if_true: BlockPredicate::Not {
3593 predicate: Box::new(BlockPredicate::MatchingBlockTag {
3594 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
3595 offset: [0i32, 0i32, 0i32],
3596 }),
3597 },
3598 then: BlockStateProvider::Simple {
3599 state: BlockStateData {
3600 block: &vanilla_blocks::DIRT,
3601 properties: &[],
3602 },
3603 },
3604 }],
3605 },
3606 foliage_provider: BlockStateProvider::Simple {
3607 state: BlockStateData {
3608 block: &vanilla_blocks::OAK_LEAVES,
3609 properties: &[
3610 ("distance", "7"),
3611 ("persistent", "false"),
3612 ("waterlogged", "false"),
3613 ],
3614 },
3615 },
3616 trunk_placer: TrunkPlacer::Fancy(TrunkPlacerBase {
3617 base_height: 3i32,
3618 height_rand_a: 11i32,
3619 height_rand_b: 0i32,
3620 }),
3621 foliage_placer: FoliagePlacer::Fancy(BlobFoliagePlacer {
3622 radius: IntProvider::Constant(2i32),
3623 offset: IntProvider::Constant(4i32),
3624 height: IntProvider::Constant(4i32),
3625 }),
3626 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
3627 limit: 0i32,
3628 lower_size: 0i32,
3629 upper_size: 0i32,
3630 min_clipped_height: Some(4i32),
3631 }),
3632 decorators: vec![
3633 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
3634 block_state_provider: BlockStateProvider::Weighted {
3635 entries: vec![
3636 WeightedBlockState {
3637 data: BlockStateData {
3638 block: &vanilla_blocks::LEAF_LITTER,
3639 properties: &[("facing", "north"), ("segment_amount", "1")],
3640 },
3641 weight: 1i32,
3642 },
3643 WeightedBlockState {
3644 data: BlockStateData {
3645 block: &vanilla_blocks::LEAF_LITTER,
3646 properties: &[("facing", "east"), ("segment_amount", "1")],
3647 },
3648 weight: 1i32,
3649 },
3650 WeightedBlockState {
3651 data: BlockStateData {
3652 block: &vanilla_blocks::LEAF_LITTER,
3653 properties: &[("facing", "south"), ("segment_amount", "1")],
3654 },
3655 weight: 1i32,
3656 },
3657 WeightedBlockState {
3658 data: BlockStateData {
3659 block: &vanilla_blocks::LEAF_LITTER,
3660 properties: &[("facing", "west"), ("segment_amount", "1")],
3661 },
3662 weight: 1i32,
3663 },
3664 WeightedBlockState {
3665 data: BlockStateData {
3666 block: &vanilla_blocks::LEAF_LITTER,
3667 properties: &[("facing", "north"), ("segment_amount", "2")],
3668 },
3669 weight: 1i32,
3670 },
3671 WeightedBlockState {
3672 data: BlockStateData {
3673 block: &vanilla_blocks::LEAF_LITTER,
3674 properties: &[("facing", "east"), ("segment_amount", "2")],
3675 },
3676 weight: 1i32,
3677 },
3678 WeightedBlockState {
3679 data: BlockStateData {
3680 block: &vanilla_blocks::LEAF_LITTER,
3681 properties: &[("facing", "south"), ("segment_amount", "2")],
3682 },
3683 weight: 1i32,
3684 },
3685 WeightedBlockState {
3686 data: BlockStateData {
3687 block: &vanilla_blocks::LEAF_LITTER,
3688 properties: &[("facing", "west"), ("segment_amount", "2")],
3689 },
3690 weight: 1i32,
3691 },
3692 WeightedBlockState {
3693 data: BlockStateData {
3694 block: &vanilla_blocks::LEAF_LITTER,
3695 properties: &[("facing", "north"), ("segment_amount", "3")],
3696 },
3697 weight: 1i32,
3698 },
3699 WeightedBlockState {
3700 data: BlockStateData {
3701 block: &vanilla_blocks::LEAF_LITTER,
3702 properties: &[("facing", "east"), ("segment_amount", "3")],
3703 },
3704 weight: 1i32,
3705 },
3706 WeightedBlockState {
3707 data: BlockStateData {
3708 block: &vanilla_blocks::LEAF_LITTER,
3709 properties: &[("facing", "south"), ("segment_amount", "3")],
3710 },
3711 weight: 1i32,
3712 },
3713 WeightedBlockState {
3714 data: BlockStateData {
3715 block: &vanilla_blocks::LEAF_LITTER,
3716 properties: &[("facing", "west"), ("segment_amount", "3")],
3717 },
3718 weight: 1i32,
3719 },
3720 ],
3721 },
3722 tries: 96i32,
3723 radius: 4i32,
3724 height: 2i32,
3725 }),
3726 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
3727 block_state_provider: BlockStateProvider::Weighted {
3728 entries: vec![
3729 WeightedBlockState {
3730 data: BlockStateData {
3731 block: &vanilla_blocks::LEAF_LITTER,
3732 properties: &[("facing", "north"), ("segment_amount", "1")],
3733 },
3734 weight: 1i32,
3735 },
3736 WeightedBlockState {
3737 data: BlockStateData {
3738 block: &vanilla_blocks::LEAF_LITTER,
3739 properties: &[("facing", "east"), ("segment_amount", "1")],
3740 },
3741 weight: 1i32,
3742 },
3743 WeightedBlockState {
3744 data: BlockStateData {
3745 block: &vanilla_blocks::LEAF_LITTER,
3746 properties: &[("facing", "south"), ("segment_amount", "1")],
3747 },
3748 weight: 1i32,
3749 },
3750 WeightedBlockState {
3751 data: BlockStateData {
3752 block: &vanilla_blocks::LEAF_LITTER,
3753 properties: &[("facing", "west"), ("segment_amount", "1")],
3754 },
3755 weight: 1i32,
3756 },
3757 WeightedBlockState {
3758 data: BlockStateData {
3759 block: &vanilla_blocks::LEAF_LITTER,
3760 properties: &[("facing", "north"), ("segment_amount", "2")],
3761 },
3762 weight: 1i32,
3763 },
3764 WeightedBlockState {
3765 data: BlockStateData {
3766 block: &vanilla_blocks::LEAF_LITTER,
3767 properties: &[("facing", "east"), ("segment_amount", "2")],
3768 },
3769 weight: 1i32,
3770 },
3771 WeightedBlockState {
3772 data: BlockStateData {
3773 block: &vanilla_blocks::LEAF_LITTER,
3774 properties: &[("facing", "south"), ("segment_amount", "2")],
3775 },
3776 weight: 1i32,
3777 },
3778 WeightedBlockState {
3779 data: BlockStateData {
3780 block: &vanilla_blocks::LEAF_LITTER,
3781 properties: &[("facing", "west"), ("segment_amount", "2")],
3782 },
3783 weight: 1i32,
3784 },
3785 WeightedBlockState {
3786 data: BlockStateData {
3787 block: &vanilla_blocks::LEAF_LITTER,
3788 properties: &[("facing", "north"), ("segment_amount", "3")],
3789 },
3790 weight: 1i32,
3791 },
3792 WeightedBlockState {
3793 data: BlockStateData {
3794 block: &vanilla_blocks::LEAF_LITTER,
3795 properties: &[("facing", "east"), ("segment_amount", "3")],
3796 },
3797 weight: 1i32,
3798 },
3799 WeightedBlockState {
3800 data: BlockStateData {
3801 block: &vanilla_blocks::LEAF_LITTER,
3802 properties: &[("facing", "south"), ("segment_amount", "3")],
3803 },
3804 weight: 1i32,
3805 },
3806 WeightedBlockState {
3807 data: BlockStateData {
3808 block: &vanilla_blocks::LEAF_LITTER,
3809 properties: &[("facing", "west"), ("segment_amount", "3")],
3810 },
3811 weight: 1i32,
3812 },
3813 WeightedBlockState {
3814 data: BlockStateData {
3815 block: &vanilla_blocks::LEAF_LITTER,
3816 properties: &[("facing", "north"), ("segment_amount", "4")],
3817 },
3818 weight: 1i32,
3819 },
3820 WeightedBlockState {
3821 data: BlockStateData {
3822 block: &vanilla_blocks::LEAF_LITTER,
3823 properties: &[("facing", "east"), ("segment_amount", "4")],
3824 },
3825 weight: 1i32,
3826 },
3827 WeightedBlockState {
3828 data: BlockStateData {
3829 block: &vanilla_blocks::LEAF_LITTER,
3830 properties: &[("facing", "south"), ("segment_amount", "4")],
3831 },
3832 weight: 1i32,
3833 },
3834 WeightedBlockState {
3835 data: BlockStateData {
3836 block: &vanilla_blocks::LEAF_LITTER,
3837 properties: &[("facing", "west"), ("segment_amount", "4")],
3838 },
3839 weight: 1i32,
3840 },
3841 ],
3842 },
3843 tries: 150i32,
3844 radius: 2i32,
3845 height: 2i32,
3846 }),
3847 ],
3848 root_placer: None,
3849 ignore_vines: true,
3850 }),
3851 id: OnceLock::new(),
3852 });
3853pub static FIREFLY_BUSH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3854 key: Identifier::vanilla_static("firefly_bush"),
3855 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
3856 to_place: BlockStateProvider::Simple {
3857 state: BlockStateData {
3858 block: &vanilla_blocks::FIREFLY_BUSH,
3859 properties: &[],
3860 },
3861 },
3862 schedule_tick: false,
3863 }),
3864 id: OnceLock::new(),
3865});
3866pub static FLOWER_CHERRY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3867 key: Identifier::vanilla_static("flower_cherry"),
3868 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
3869 to_place: BlockStateProvider::Weighted {
3870 entries: vec![
3871 WeightedBlockState {
3872 data: BlockStateData {
3873 block: &vanilla_blocks::PINK_PETALS,
3874 properties: &[("facing", "north"), ("flower_amount", "1")],
3875 },
3876 weight: 1i32,
3877 },
3878 WeightedBlockState {
3879 data: BlockStateData {
3880 block: &vanilla_blocks::PINK_PETALS,
3881 properties: &[("facing", "east"), ("flower_amount", "1")],
3882 },
3883 weight: 1i32,
3884 },
3885 WeightedBlockState {
3886 data: BlockStateData {
3887 block: &vanilla_blocks::PINK_PETALS,
3888 properties: &[("facing", "south"), ("flower_amount", "1")],
3889 },
3890 weight: 1i32,
3891 },
3892 WeightedBlockState {
3893 data: BlockStateData {
3894 block: &vanilla_blocks::PINK_PETALS,
3895 properties: &[("facing", "west"), ("flower_amount", "1")],
3896 },
3897 weight: 1i32,
3898 },
3899 WeightedBlockState {
3900 data: BlockStateData {
3901 block: &vanilla_blocks::PINK_PETALS,
3902 properties: &[("facing", "north"), ("flower_amount", "2")],
3903 },
3904 weight: 1i32,
3905 },
3906 WeightedBlockState {
3907 data: BlockStateData {
3908 block: &vanilla_blocks::PINK_PETALS,
3909 properties: &[("facing", "east"), ("flower_amount", "2")],
3910 },
3911 weight: 1i32,
3912 },
3913 WeightedBlockState {
3914 data: BlockStateData {
3915 block: &vanilla_blocks::PINK_PETALS,
3916 properties: &[("facing", "south"), ("flower_amount", "2")],
3917 },
3918 weight: 1i32,
3919 },
3920 WeightedBlockState {
3921 data: BlockStateData {
3922 block: &vanilla_blocks::PINK_PETALS,
3923 properties: &[("facing", "west"), ("flower_amount", "2")],
3924 },
3925 weight: 1i32,
3926 },
3927 WeightedBlockState {
3928 data: BlockStateData {
3929 block: &vanilla_blocks::PINK_PETALS,
3930 properties: &[("facing", "north"), ("flower_amount", "3")],
3931 },
3932 weight: 1i32,
3933 },
3934 WeightedBlockState {
3935 data: BlockStateData {
3936 block: &vanilla_blocks::PINK_PETALS,
3937 properties: &[("facing", "east"), ("flower_amount", "3")],
3938 },
3939 weight: 1i32,
3940 },
3941 WeightedBlockState {
3942 data: BlockStateData {
3943 block: &vanilla_blocks::PINK_PETALS,
3944 properties: &[("facing", "south"), ("flower_amount", "3")],
3945 },
3946 weight: 1i32,
3947 },
3948 WeightedBlockState {
3949 data: BlockStateData {
3950 block: &vanilla_blocks::PINK_PETALS,
3951 properties: &[("facing", "west"), ("flower_amount", "3")],
3952 },
3953 weight: 1i32,
3954 },
3955 WeightedBlockState {
3956 data: BlockStateData {
3957 block: &vanilla_blocks::PINK_PETALS,
3958 properties: &[("facing", "north"), ("flower_amount", "4")],
3959 },
3960 weight: 1i32,
3961 },
3962 WeightedBlockState {
3963 data: BlockStateData {
3964 block: &vanilla_blocks::PINK_PETALS,
3965 properties: &[("facing", "east"), ("flower_amount", "4")],
3966 },
3967 weight: 1i32,
3968 },
3969 WeightedBlockState {
3970 data: BlockStateData {
3971 block: &vanilla_blocks::PINK_PETALS,
3972 properties: &[("facing", "south"), ("flower_amount", "4")],
3973 },
3974 weight: 1i32,
3975 },
3976 WeightedBlockState {
3977 data: BlockStateData {
3978 block: &vanilla_blocks::PINK_PETALS,
3979 properties: &[("facing", "west"), ("flower_amount", "4")],
3980 },
3981 weight: 1i32,
3982 },
3983 ],
3984 },
3985 schedule_tick: false,
3986 }),
3987 id: OnceLock::new(),
3988});
3989pub static FLOWER_DEFAULT: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
3990 key: Identifier::vanilla_static("flower_default"),
3991 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
3992 to_place: BlockStateProvider::Weighted {
3993 entries: vec![
3994 WeightedBlockState {
3995 data: BlockStateData {
3996 block: &vanilla_blocks::POPPY,
3997 properties: &[],
3998 },
3999 weight: 2i32,
4000 },
4001 WeightedBlockState {
4002 data: BlockStateData {
4003 block: &vanilla_blocks::DANDELION,
4004 properties: &[],
4005 },
4006 weight: 1i32,
4007 },
4008 ],
4009 },
4010 schedule_tick: false,
4011 }),
4012 id: OnceLock::new(),
4013});
4014pub static FLOWER_FLOWER_FOREST: LazyLock<ConfiguredFeature> =
4015 LazyLock::new(|| ConfiguredFeature {
4016 key: Identifier::vanilla_static("flower_flower_forest"),
4017 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4018 to_place: BlockStateProvider::Noise(NoiseProvider {
4019 noise: FeatureNoiseParameters {
4020 first_octave: 0i32,
4021 amplitudes: vec![1f64],
4022 },
4023 scale: 0.020833334f32,
4024 seed: 2345i64,
4025 states: vec![
4026 BlockStateData {
4027 block: &vanilla_blocks::DANDELION,
4028 properties: &[],
4029 },
4030 BlockStateData {
4031 block: &vanilla_blocks::POPPY,
4032 properties: &[],
4033 },
4034 BlockStateData {
4035 block: &vanilla_blocks::ALLIUM,
4036 properties: &[],
4037 },
4038 BlockStateData {
4039 block: &vanilla_blocks::AZURE_BLUET,
4040 properties: &[],
4041 },
4042 BlockStateData {
4043 block: &vanilla_blocks::RED_TULIP,
4044 properties: &[],
4045 },
4046 BlockStateData {
4047 block: &vanilla_blocks::ORANGE_TULIP,
4048 properties: &[],
4049 },
4050 BlockStateData {
4051 block: &vanilla_blocks::WHITE_TULIP,
4052 properties: &[],
4053 },
4054 BlockStateData {
4055 block: &vanilla_blocks::PINK_TULIP,
4056 properties: &[],
4057 },
4058 BlockStateData {
4059 block: &vanilla_blocks::OXEYE_DAISY,
4060 properties: &[],
4061 },
4062 BlockStateData {
4063 block: &vanilla_blocks::CORNFLOWER,
4064 properties: &[],
4065 },
4066 BlockStateData {
4067 block: &vanilla_blocks::LILY_OF_THE_VALLEY,
4068 properties: &[],
4069 },
4070 ],
4071 }),
4072 schedule_tick: false,
4073 }),
4074 id: OnceLock::new(),
4075 });
4076pub static FLOWER_MEADOW: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4077 key: Identifier::vanilla_static("flower_meadow"),
4078 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4079 to_place: BlockStateProvider::DualNoise(DualNoiseProvider {
4080 noise: FeatureNoiseParameters {
4081 first_octave: -3i32,
4082 amplitudes: vec![1f64],
4083 },
4084 scale: 1f32,
4085 seed: 2345i64,
4086 slow_noise: FeatureNoiseParameters {
4087 first_octave: -10i32,
4088 amplitudes: vec![1f64],
4089 },
4090 slow_scale: 1f32,
4091 states: vec![
4092 BlockStateData {
4093 block: &vanilla_blocks::TALL_GRASS,
4094 properties: &[("half", "lower")],
4095 },
4096 BlockStateData {
4097 block: &vanilla_blocks::ALLIUM,
4098 properties: &[],
4099 },
4100 BlockStateData {
4101 block: &vanilla_blocks::POPPY,
4102 properties: &[],
4103 },
4104 BlockStateData {
4105 block: &vanilla_blocks::AZURE_BLUET,
4106 properties: &[],
4107 },
4108 BlockStateData {
4109 block: &vanilla_blocks::DANDELION,
4110 properties: &[],
4111 },
4112 BlockStateData {
4113 block: &vanilla_blocks::CORNFLOWER,
4114 properties: &[],
4115 },
4116 BlockStateData {
4117 block: &vanilla_blocks::OXEYE_DAISY,
4118 properties: &[],
4119 },
4120 BlockStateData {
4121 block: &vanilla_blocks::SHORT_GRASS,
4122 properties: &[],
4123 },
4124 ],
4125 variety: [1i32, 3i32],
4126 }),
4127 schedule_tick: false,
4128 }),
4129 id: OnceLock::new(),
4130});
4131pub static FLOWER_PALE_GARDEN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4132 key: Identifier::vanilla_static("flower_pale_garden"),
4133 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4134 to_place: BlockStateProvider::Simple {
4135 state: BlockStateData {
4136 block: &vanilla_blocks::CLOSED_EYEBLOSSOM,
4137 properties: &[],
4138 },
4139 },
4140 schedule_tick: true,
4141 }),
4142 id: OnceLock::new(),
4143});
4144pub static FLOWER_PLAIN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4145 key: Identifier::vanilla_static("flower_plain"),
4146 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4147 to_place: BlockStateProvider::NoiseThreshold(NoiseThresholdProvider {
4148 noise: FeatureNoiseParameters {
4149 first_octave: 0i32,
4150 amplitudes: vec![1f64],
4151 },
4152 scale: 0.005f32,
4153 seed: 2345i64,
4154 threshold: -0.8f32,
4155 high_chance: 0.33333334f32,
4156 default_state: BlockStateData {
4157 block: &vanilla_blocks::DANDELION,
4158 properties: &[],
4159 },
4160 low_states: vec![
4161 BlockStateData {
4162 block: &vanilla_blocks::ORANGE_TULIP,
4163 properties: &[],
4164 },
4165 BlockStateData {
4166 block: &vanilla_blocks::RED_TULIP,
4167 properties: &[],
4168 },
4169 BlockStateData {
4170 block: &vanilla_blocks::PINK_TULIP,
4171 properties: &[],
4172 },
4173 BlockStateData {
4174 block: &vanilla_blocks::WHITE_TULIP,
4175 properties: &[],
4176 },
4177 ],
4178 high_states: vec![
4179 BlockStateData {
4180 block: &vanilla_blocks::POPPY,
4181 properties: &[],
4182 },
4183 BlockStateData {
4184 block: &vanilla_blocks::AZURE_BLUET,
4185 properties: &[],
4186 },
4187 BlockStateData {
4188 block: &vanilla_blocks::OXEYE_DAISY,
4189 properties: &[],
4190 },
4191 BlockStateData {
4192 block: &vanilla_blocks::CORNFLOWER,
4193 properties: &[],
4194 },
4195 ],
4196 }),
4197 schedule_tick: false,
4198 }),
4199 id: OnceLock::new(),
4200});
4201pub static FLOWER_SWAMP: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4202 key: Identifier::vanilla_static("flower_swamp"),
4203 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4204 to_place: BlockStateProvider::Simple {
4205 state: BlockStateData {
4206 block: &vanilla_blocks::BLUE_ORCHID,
4207 properties: &[],
4208 },
4209 },
4210 schedule_tick: false,
4211 }),
4212 id: OnceLock::new(),
4213});
4214pub static FOREST_FLOWERS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4215 key: Identifier::vanilla_static("forest_flowers"),
4216 kind: ConfiguredFeatureKind::SimpleRandomSelector(SimpleRandomSelectorConfiguration {
4217 features: vec![
4218 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
4219 feature: ConfiguredFeatureRef::Inline(Box::new(
4220 ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4221 to_place: BlockStateProvider::Simple {
4222 state: BlockStateData {
4223 block: &vanilla_blocks::LILAC,
4224 properties: &[("half", "lower")],
4225 },
4226 },
4227 schedule_tick: false,
4228 }),
4229 )),
4230 placement: vec![
4231 PlacementModifier::Count {
4232 count: IntProvider::Constant(96i32),
4233 },
4234 PlacementModifier::RandomOffset {
4235 xz_spread: IntProvider::Trapezoid {
4236 min: -7i32,
4237 max: 7i32,
4238 plateau: 0i32,
4239 },
4240 y_spread: IntProvider::Trapezoid {
4241 min: -3i32,
4242 max: 3i32,
4243 plateau: 0i32,
4244 },
4245 },
4246 PlacementModifier::BlockPredicateFilter {
4247 predicate: BlockPredicate::MatchingBlockTag {
4248 tag: Identifier::vanilla_static("air"),
4249 offset: [0i32, 0i32, 0i32],
4250 },
4251 },
4252 ],
4253 })),
4254 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
4255 feature: ConfiguredFeatureRef::Inline(Box::new(
4256 ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4257 to_place: BlockStateProvider::Simple {
4258 state: BlockStateData {
4259 block: &vanilla_blocks::ROSE_BUSH,
4260 properties: &[("half", "lower")],
4261 },
4262 },
4263 schedule_tick: false,
4264 }),
4265 )),
4266 placement: vec![
4267 PlacementModifier::Count {
4268 count: IntProvider::Constant(96i32),
4269 },
4270 PlacementModifier::RandomOffset {
4271 xz_spread: IntProvider::Trapezoid {
4272 min: -7i32,
4273 max: 7i32,
4274 plateau: 0i32,
4275 },
4276 y_spread: IntProvider::Trapezoid {
4277 min: -3i32,
4278 max: 3i32,
4279 plateau: 0i32,
4280 },
4281 },
4282 PlacementModifier::BlockPredicateFilter {
4283 predicate: BlockPredicate::MatchingBlockTag {
4284 tag: Identifier::vanilla_static("air"),
4285 offset: [0i32, 0i32, 0i32],
4286 },
4287 },
4288 ],
4289 })),
4290 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
4291 feature: ConfiguredFeatureRef::Inline(Box::new(
4292 ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4293 to_place: BlockStateProvider::Simple {
4294 state: BlockStateData {
4295 block: &vanilla_blocks::PEONY,
4296 properties: &[("half", "lower")],
4297 },
4298 },
4299 schedule_tick: false,
4300 }),
4301 )),
4302 placement: vec![
4303 PlacementModifier::Count {
4304 count: IntProvider::Constant(96i32),
4305 },
4306 PlacementModifier::RandomOffset {
4307 xz_spread: IntProvider::Trapezoid {
4308 min: -7i32,
4309 max: 7i32,
4310 plateau: 0i32,
4311 },
4312 y_spread: IntProvider::Trapezoid {
4313 min: -3i32,
4314 max: 3i32,
4315 plateau: 0i32,
4316 },
4317 },
4318 PlacementModifier::BlockPredicateFilter {
4319 predicate: BlockPredicate::MatchingBlockTag {
4320 tag: Identifier::vanilla_static("air"),
4321 offset: [0i32, 0i32, 0i32],
4322 },
4323 },
4324 ],
4325 })),
4326 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
4327 feature: ConfiguredFeatureRef::Inline(Box::new(
4328 ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4329 to_place: BlockStateProvider::Simple {
4330 state: BlockStateData {
4331 block: &vanilla_blocks::LILY_OF_THE_VALLEY,
4332 properties: &[],
4333 },
4334 },
4335 schedule_tick: false,
4336 }),
4337 )),
4338 placement: vec![
4339 PlacementModifier::Count {
4340 count: IntProvider::Constant(96i32),
4341 },
4342 PlacementModifier::RandomOffset {
4343 xz_spread: IntProvider::Trapezoid {
4344 min: -7i32,
4345 max: 7i32,
4346 plateau: 0i32,
4347 },
4348 y_spread: IntProvider::Trapezoid {
4349 min: -3i32,
4350 max: 3i32,
4351 plateau: 0i32,
4352 },
4353 },
4354 PlacementModifier::BlockPredicateFilter {
4355 predicate: BlockPredicate::MatchingBlockTag {
4356 tag: Identifier::vanilla_static("air"),
4357 offset: [0i32, 0i32, 0i32],
4358 },
4359 },
4360 ],
4361 })),
4362 ],
4363 }),
4364 id: OnceLock::new(),
4365});
4366pub static FOREST_ROCK: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4367 key: Identifier::vanilla_static("forest_rock"),
4368 kind: ConfiguredFeatureKind::BlockBlob(BlockBlobConfiguration {
4369 state: BlockStateData {
4370 block: &vanilla_blocks::MOSSY_COBBLESTONE,
4371 properties: &[],
4372 },
4373 can_place_on: BlockPredicate::MatchingBlockTag {
4374 tag: Identifier::vanilla_static("forest_rock_can_place_on"),
4375 offset: [0i32, 0i32, 0i32],
4376 },
4377 }),
4378 id: OnceLock::new(),
4379});
4380pub static FOSSIL_COAL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4381 key: Identifier::vanilla_static("fossil_coal"),
4382 kind: ConfiguredFeatureKind::Fossil(FossilConfiguration {
4383 fossil_structures: vec![
4384 Identifier::vanilla_static("fossil/spine_1"),
4385 Identifier::vanilla_static("fossil/spine_2"),
4386 Identifier::vanilla_static("fossil/spine_3"),
4387 Identifier::vanilla_static("fossil/spine_4"),
4388 Identifier::vanilla_static("fossil/skull_1"),
4389 Identifier::vanilla_static("fossil/skull_2"),
4390 Identifier::vanilla_static("fossil/skull_3"),
4391 Identifier::vanilla_static("fossil/skull_4"),
4392 ],
4393 overlay_structures: vec![
4394 Identifier::vanilla_static("fossil/spine_1_coal"),
4395 Identifier::vanilla_static("fossil/spine_2_coal"),
4396 Identifier::vanilla_static("fossil/spine_3_coal"),
4397 Identifier::vanilla_static("fossil/spine_4_coal"),
4398 Identifier::vanilla_static("fossil/skull_1_coal"),
4399 Identifier::vanilla_static("fossil/skull_2_coal"),
4400 Identifier::vanilla_static("fossil/skull_3_coal"),
4401 Identifier::vanilla_static("fossil/skull_4_coal"),
4402 ],
4403 fossil_processors: Identifier::vanilla_static("fossil_rot"),
4404 overlay_processors: Identifier::vanilla_static("fossil_coal"),
4405 max_empty_corners_allowed: 4i32,
4406 }),
4407 id: OnceLock::new(),
4408});
4409pub static FOSSIL_DIAMONDS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4410 key: Identifier::vanilla_static("fossil_diamonds"),
4411 kind: ConfiguredFeatureKind::Fossil(FossilConfiguration {
4412 fossil_structures: vec![
4413 Identifier::vanilla_static("fossil/spine_1"),
4414 Identifier::vanilla_static("fossil/spine_2"),
4415 Identifier::vanilla_static("fossil/spine_3"),
4416 Identifier::vanilla_static("fossil/spine_4"),
4417 Identifier::vanilla_static("fossil/skull_1"),
4418 Identifier::vanilla_static("fossil/skull_2"),
4419 Identifier::vanilla_static("fossil/skull_3"),
4420 Identifier::vanilla_static("fossil/skull_4"),
4421 ],
4422 overlay_structures: vec![
4423 Identifier::vanilla_static("fossil/spine_1_coal"),
4424 Identifier::vanilla_static("fossil/spine_2_coal"),
4425 Identifier::vanilla_static("fossil/spine_3_coal"),
4426 Identifier::vanilla_static("fossil/spine_4_coal"),
4427 Identifier::vanilla_static("fossil/skull_1_coal"),
4428 Identifier::vanilla_static("fossil/skull_2_coal"),
4429 Identifier::vanilla_static("fossil/skull_3_coal"),
4430 Identifier::vanilla_static("fossil/skull_4_coal"),
4431 ],
4432 fossil_processors: Identifier::vanilla_static("fossil_rot"),
4433 overlay_processors: Identifier::vanilla_static("fossil_diamonds"),
4434 max_empty_corners_allowed: 4i32,
4435 }),
4436 id: OnceLock::new(),
4437});
4438pub static FREEZE_TOP_LAYER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4439 key: Identifier::vanilla_static("freeze_top_layer"),
4440 kind: ConfiguredFeatureKind::FreezeTopLayer,
4441 id: OnceLock::new(),
4442});
4443pub static GLOW_LICHEN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4444 key: Identifier::vanilla_static("glow_lichen"),
4445 kind: ConfiguredFeatureKind::MultifaceGrowth(MultifaceGrowthConfiguration {
4446 block: &vanilla_blocks::GLOW_LICHEN,
4447 search_range: 20i32,
4448 can_place_on_floor: false,
4449 can_place_on_ceiling: true,
4450 can_place_on_wall: true,
4451 chance_of_spreading: 0.5f32,
4452 can_be_placed_on: vec![
4453 &vanilla_blocks::STONE,
4454 &vanilla_blocks::ANDESITE,
4455 &vanilla_blocks::DIORITE,
4456 &vanilla_blocks::GRANITE,
4457 &vanilla_blocks::DRIPSTONE_BLOCK,
4458 &vanilla_blocks::CALCITE,
4459 &vanilla_blocks::TUFF,
4460 &vanilla_blocks::DEEPSLATE,
4461 ],
4462 }),
4463 id: OnceLock::new(),
4464});
4465pub static GLOWSTONE_EXTRA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4466 key: Identifier::vanilla_static("glowstone_extra"),
4467 kind: ConfiguredFeatureKind::GlowstoneBlob,
4468 id: OnceLock::new(),
4469});
4470pub static GRASS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4471 key: Identifier::vanilla_static("grass"),
4472 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4473 to_place: BlockStateProvider::Simple {
4474 state: BlockStateData {
4475 block: &vanilla_blocks::SHORT_GRASS,
4476 properties: &[],
4477 },
4478 },
4479 schedule_tick: false,
4480 }),
4481 id: OnceLock::new(),
4482});
4483pub static GRASS_JUNGLE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4484 key: Identifier::vanilla_static("grass_jungle"),
4485 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4486 to_place: BlockStateProvider::Weighted {
4487 entries: vec![
4488 WeightedBlockState {
4489 data: BlockStateData {
4490 block: &vanilla_blocks::SHORT_GRASS,
4491 properties: &[],
4492 },
4493 weight: 3i32,
4494 },
4495 WeightedBlockState {
4496 data: BlockStateData {
4497 block: &vanilla_blocks::FERN,
4498 properties: &[],
4499 },
4500 weight: 1i32,
4501 },
4502 ],
4503 },
4504 schedule_tick: false,
4505 }),
4506 id: OnceLock::new(),
4507});
4508pub static HUGE_BROWN_MUSHROOM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4509 key: Identifier::vanilla_static("huge_brown_mushroom"),
4510 kind: ConfiguredFeatureKind::HugeBrownMushroom(HugeMushroomConfiguration {
4511 cap_provider: BlockStateProvider::Simple {
4512 state: BlockStateData {
4513 block: &vanilla_blocks::BROWN_MUSHROOM_BLOCK,
4514 properties: &[
4515 ("down", "false"),
4516 ("east", "true"),
4517 ("north", "true"),
4518 ("south", "true"),
4519 ("up", "true"),
4520 ("west", "true"),
4521 ],
4522 },
4523 },
4524 stem_provider: BlockStateProvider::Simple {
4525 state: BlockStateData {
4526 block: &vanilla_blocks::MUSHROOM_STEM,
4527 properties: &[
4528 ("down", "false"),
4529 ("east", "true"),
4530 ("north", "true"),
4531 ("south", "true"),
4532 ("up", "false"),
4533 ("west", "true"),
4534 ],
4535 },
4536 },
4537 foliage_radius: 3i32,
4538 can_place_on: BlockPredicate::MatchingBlockTag {
4539 tag: Identifier::vanilla_static("huge_brown_mushroom_can_place_on"),
4540 offset: [0i32, 0i32, 0i32],
4541 },
4542 }),
4543 id: OnceLock::new(),
4544});
4545pub static HUGE_RED_MUSHROOM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4546 key: Identifier::vanilla_static("huge_red_mushroom"),
4547 kind: ConfiguredFeatureKind::HugeRedMushroom(HugeMushroomConfiguration {
4548 cap_provider: BlockStateProvider::Simple {
4549 state: BlockStateData {
4550 block: &vanilla_blocks::RED_MUSHROOM_BLOCK,
4551 properties: &[
4552 ("down", "false"),
4553 ("east", "true"),
4554 ("north", "true"),
4555 ("south", "true"),
4556 ("up", "true"),
4557 ("west", "true"),
4558 ],
4559 },
4560 },
4561 stem_provider: BlockStateProvider::Simple {
4562 state: BlockStateData {
4563 block: &vanilla_blocks::MUSHROOM_STEM,
4564 properties: &[
4565 ("down", "false"),
4566 ("east", "true"),
4567 ("north", "true"),
4568 ("south", "true"),
4569 ("up", "false"),
4570 ("west", "true"),
4571 ],
4572 },
4573 },
4574 foliage_radius: 2i32,
4575 can_place_on: BlockPredicate::MatchingBlockTag {
4576 tag: Identifier::vanilla_static("huge_red_mushroom_can_place_on"),
4577 offset: [0i32, 0i32, 0i32],
4578 },
4579 }),
4580 id: OnceLock::new(),
4581});
4582pub static ICE_PATCH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4583 key: Identifier::vanilla_static("ice_patch"),
4584 kind: ConfiguredFeatureKind::Disk(DiskConfiguration {
4585 state_provider: BlockStateProvider::Simple {
4586 state: BlockStateData {
4587 block: &vanilla_blocks::PACKED_ICE,
4588 properties: &[],
4589 },
4590 },
4591 target: BlockPredicate::MatchingBlocks {
4592 blocks: BlockRefList(vec![
4593 &vanilla_blocks::DIRT,
4594 &vanilla_blocks::GRASS_BLOCK,
4595 &vanilla_blocks::PODZOL,
4596 &vanilla_blocks::COARSE_DIRT,
4597 &vanilla_blocks::MYCELIUM,
4598 &vanilla_blocks::SNOW_BLOCK,
4599 &vanilla_blocks::ICE,
4600 ]),
4601 offset: [0i32, 0i32, 0i32],
4602 },
4603 radius: IntProvider::Uniform {
4604 min_inclusive: 2i32,
4605 max_inclusive: 3i32,
4606 },
4607 half_height: 1i32,
4608 }),
4609 id: OnceLock::new(),
4610});
4611pub static ICE_SPIKE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4612 key: Identifier::vanilla_static("ice_spike"),
4613 kind: ConfiguredFeatureKind::Spike(SpikeConfiguration {
4614 state: BlockStateData {
4615 block: &vanilla_blocks::PACKED_ICE,
4616 properties: &[],
4617 },
4618 can_place_on: BlockPredicate::MatchingBlocks {
4619 blocks: BlockRefList(vec![&vanilla_blocks::SNOW_BLOCK]),
4620 offset: [0i32, 0i32, 0i32],
4621 },
4622 can_replace: BlockPredicate::MatchingBlockTag {
4623 tag: Identifier::vanilla_static("ice_spike_replaceable"),
4624 offset: [0i32, 0i32, 0i32],
4625 },
4626 }),
4627 id: OnceLock::new(),
4628});
4629pub static ICEBERG_BLUE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4630 key: Identifier::vanilla_static("iceberg_blue"),
4631 kind: ConfiguredFeatureKind::Iceberg(BlockStateData {
4632 block: &vanilla_blocks::BLUE_ICE,
4633 properties: &[],
4634 }),
4635 id: OnceLock::new(),
4636});
4637pub static ICEBERG_PACKED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4638 key: Identifier::vanilla_static("iceberg_packed"),
4639 kind: ConfiguredFeatureKind::Iceberg(BlockStateData {
4640 block: &vanilla_blocks::PACKED_ICE,
4641 properties: &[],
4642 }),
4643 id: OnceLock::new(),
4644});
4645pub static JUNGLE_BUSH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4646 key: Identifier::vanilla_static("jungle_bush"),
4647 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
4648 trunk_provider: BlockStateProvider::Simple {
4649 state: BlockStateData {
4650 block: &vanilla_blocks::JUNGLE_LOG,
4651 properties: &[("axis", "y")],
4652 },
4653 },
4654 below_trunk_provider: BlockStateProvider::RuleBased {
4655 fallback: None,
4656 rules: vec![RuleBasedStateProviderRule {
4657 if_true: BlockPredicate::Not {
4658 predicate: Box::new(BlockPredicate::MatchingBlockTag {
4659 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
4660 offset: [0i32, 0i32, 0i32],
4661 }),
4662 },
4663 then: BlockStateProvider::Simple {
4664 state: BlockStateData {
4665 block: &vanilla_blocks::DIRT,
4666 properties: &[],
4667 },
4668 },
4669 }],
4670 },
4671 foliage_provider: BlockStateProvider::Simple {
4672 state: BlockStateData {
4673 block: &vanilla_blocks::OAK_LEAVES,
4674 properties: &[
4675 ("distance", "7"),
4676 ("persistent", "false"),
4677 ("waterlogged", "false"),
4678 ],
4679 },
4680 },
4681 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
4682 base_height: 1i32,
4683 height_rand_a: 0i32,
4684 height_rand_b: 0i32,
4685 }),
4686 foliage_placer: FoliagePlacer::Bush(BlobFoliagePlacer {
4687 radius: IntProvider::Constant(2i32),
4688 offset: IntProvider::Constant(1i32),
4689 height: IntProvider::Constant(2i32),
4690 }),
4691 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
4692 limit: 0i32,
4693 lower_size: 0i32,
4694 upper_size: 0i32,
4695 min_clipped_height: None,
4696 }),
4697 decorators: vec![],
4698 root_placer: None,
4699 ignore_vines: false,
4700 }),
4701 id: OnceLock::new(),
4702});
4703pub static JUNGLE_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4704 key: Identifier::vanilla_static("jungle_tree"),
4705 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
4706 trunk_provider: BlockStateProvider::Simple {
4707 state: BlockStateData {
4708 block: &vanilla_blocks::JUNGLE_LOG,
4709 properties: &[("axis", "y")],
4710 },
4711 },
4712 below_trunk_provider: BlockStateProvider::RuleBased {
4713 fallback: None,
4714 rules: vec![RuleBasedStateProviderRule {
4715 if_true: BlockPredicate::Not {
4716 predicate: Box::new(BlockPredicate::MatchingBlockTag {
4717 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
4718 offset: [0i32, 0i32, 0i32],
4719 }),
4720 },
4721 then: BlockStateProvider::Simple {
4722 state: BlockStateData {
4723 block: &vanilla_blocks::DIRT,
4724 properties: &[],
4725 },
4726 },
4727 }],
4728 },
4729 foliage_provider: BlockStateProvider::Simple {
4730 state: BlockStateData {
4731 block: &vanilla_blocks::JUNGLE_LEAVES,
4732 properties: &[
4733 ("distance", "7"),
4734 ("persistent", "false"),
4735 ("waterlogged", "false"),
4736 ],
4737 },
4738 },
4739 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
4740 base_height: 4i32,
4741 height_rand_a: 8i32,
4742 height_rand_b: 0i32,
4743 }),
4744 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
4745 radius: IntProvider::Constant(2i32),
4746 offset: IntProvider::Constant(0i32),
4747 height: IntProvider::Constant(3i32),
4748 }),
4749 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
4750 limit: 1i32,
4751 lower_size: 0i32,
4752 upper_size: 1i32,
4753 min_clipped_height: None,
4754 }),
4755 decorators: vec![
4756 TreeDecorator::Cocoa {
4757 probability: 0.2f32,
4758 },
4759 TreeDecorator::TrunkVine,
4760 TreeDecorator::LeaveVine {
4761 probability: 0.25f32,
4762 },
4763 ],
4764 root_placer: None,
4765 ignore_vines: true,
4766 }),
4767 id: OnceLock::new(),
4768});
4769pub static JUNGLE_TREE_NO_VINE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4770 key: Identifier::vanilla_static("jungle_tree_no_vine"),
4771 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
4772 trunk_provider: BlockStateProvider::Simple {
4773 state: BlockStateData {
4774 block: &vanilla_blocks::JUNGLE_LOG,
4775 properties: &[("axis", "y")],
4776 },
4777 },
4778 below_trunk_provider: BlockStateProvider::RuleBased {
4779 fallback: None,
4780 rules: vec![RuleBasedStateProviderRule {
4781 if_true: BlockPredicate::Not {
4782 predicate: Box::new(BlockPredicate::MatchingBlockTag {
4783 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
4784 offset: [0i32, 0i32, 0i32],
4785 }),
4786 },
4787 then: BlockStateProvider::Simple {
4788 state: BlockStateData {
4789 block: &vanilla_blocks::DIRT,
4790 properties: &[],
4791 },
4792 },
4793 }],
4794 },
4795 foliage_provider: BlockStateProvider::Simple {
4796 state: BlockStateData {
4797 block: &vanilla_blocks::JUNGLE_LEAVES,
4798 properties: &[
4799 ("distance", "7"),
4800 ("persistent", "false"),
4801 ("waterlogged", "false"),
4802 ],
4803 },
4804 },
4805 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
4806 base_height: 4i32,
4807 height_rand_a: 8i32,
4808 height_rand_b: 0i32,
4809 }),
4810 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
4811 radius: IntProvider::Constant(2i32),
4812 offset: IntProvider::Constant(0i32),
4813 height: IntProvider::Constant(3i32),
4814 }),
4815 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
4816 limit: 1i32,
4817 lower_size: 0i32,
4818 upper_size: 1i32,
4819 min_clipped_height: None,
4820 }),
4821 decorators: vec![],
4822 root_placer: None,
4823 ignore_vines: true,
4824 }),
4825 id: OnceLock::new(),
4826});
4827pub static KELP: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4828 key: Identifier::vanilla_static("kelp"),
4829 kind: ConfiguredFeatureKind::Kelp,
4830 id: OnceLock::new(),
4831});
4832pub static LAKE_LAVA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4833 key: Identifier::vanilla_static("lake_lava"),
4834 kind: ConfiguredFeatureKind::Lake(LakeConfiguration {
4835 fluid: BlockStateProvider::Simple {
4836 state: BlockStateData {
4837 block: &vanilla_blocks::LAVA,
4838 properties: &[("level", "0")],
4839 },
4840 },
4841 barrier: BlockStateProvider::Simple {
4842 state: BlockStateData {
4843 block: &vanilla_blocks::STONE,
4844 properties: &[],
4845 },
4846 },
4847 }),
4848 id: OnceLock::new(),
4849});
4850pub static LARGE_BASALT_COLUMNS: LazyLock<ConfiguredFeature> =
4851 LazyLock::new(|| ConfiguredFeature {
4852 key: Identifier::vanilla_static("large_basalt_columns"),
4853 kind: ConfiguredFeatureKind::BasaltColumns(BasaltColumnsConfiguration {
4854 height: IntProvider::Uniform {
4855 min_inclusive: 5i32,
4856 max_inclusive: 10i32,
4857 },
4858 reach: IntProvider::Uniform {
4859 min_inclusive: 2i32,
4860 max_inclusive: 3i32,
4861 },
4862 }),
4863 id: OnceLock::new(),
4864 });
4865pub static LARGE_DRIPSTONE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4866 key: Identifier::vanilla_static("large_dripstone"),
4867 kind: ConfiguredFeatureKind::LargeDripstone(LargeDripstoneConfiguration {
4868 floor_to_ceiling_search_range: 30i32,
4869 column_radius: IntProvider::Uniform {
4870 min_inclusive: 3i32,
4871 max_inclusive: 19i32,
4872 },
4873 height_scale: FloatProvider::Uniform {
4874 min_inclusive: 0.4f32,
4875 max_exclusive: 2f32,
4876 },
4877 max_column_radius_to_cave_height_ratio: 0.33f32,
4878 stalactite_bluntness: FloatProvider::Uniform {
4879 min_inclusive: 0.3f32,
4880 max_exclusive: 0.9f32,
4881 },
4882 stalagmite_bluntness: FloatProvider::Uniform {
4883 min_inclusive: 0.4f32,
4884 max_exclusive: 1f32,
4885 },
4886 wind_speed: FloatProvider::Uniform {
4887 min_inclusive: 0f32,
4888 max_exclusive: 0.3f32,
4889 },
4890 min_radius_for_wind: 4i32,
4891 min_bluntness_for_wind: 0.6f32,
4892 }),
4893 id: OnceLock::new(),
4894});
4895pub static LARGE_FERN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4896 key: Identifier::vanilla_static("large_fern"),
4897 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4898 to_place: BlockStateProvider::Simple {
4899 state: BlockStateData {
4900 block: &vanilla_blocks::LARGE_FERN,
4901 properties: &[("half", "lower")],
4902 },
4903 },
4904 schedule_tick: false,
4905 }),
4906 id: OnceLock::new(),
4907});
4908pub static LEAF_LITTER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
4909 key: Identifier::vanilla_static("leaf_litter"),
4910 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
4911 to_place: BlockStateProvider::Weighted {
4912 entries: vec![
4913 WeightedBlockState {
4914 data: BlockStateData {
4915 block: &vanilla_blocks::LEAF_LITTER,
4916 properties: &[("facing", "north"), ("segment_amount", "1")],
4917 },
4918 weight: 1i32,
4919 },
4920 WeightedBlockState {
4921 data: BlockStateData {
4922 block: &vanilla_blocks::LEAF_LITTER,
4923 properties: &[("facing", "east"), ("segment_amount", "1")],
4924 },
4925 weight: 1i32,
4926 },
4927 WeightedBlockState {
4928 data: BlockStateData {
4929 block: &vanilla_blocks::LEAF_LITTER,
4930 properties: &[("facing", "south"), ("segment_amount", "1")],
4931 },
4932 weight: 1i32,
4933 },
4934 WeightedBlockState {
4935 data: BlockStateData {
4936 block: &vanilla_blocks::LEAF_LITTER,
4937 properties: &[("facing", "west"), ("segment_amount", "1")],
4938 },
4939 weight: 1i32,
4940 },
4941 WeightedBlockState {
4942 data: BlockStateData {
4943 block: &vanilla_blocks::LEAF_LITTER,
4944 properties: &[("facing", "north"), ("segment_amount", "2")],
4945 },
4946 weight: 1i32,
4947 },
4948 WeightedBlockState {
4949 data: BlockStateData {
4950 block: &vanilla_blocks::LEAF_LITTER,
4951 properties: &[("facing", "east"), ("segment_amount", "2")],
4952 },
4953 weight: 1i32,
4954 },
4955 WeightedBlockState {
4956 data: BlockStateData {
4957 block: &vanilla_blocks::LEAF_LITTER,
4958 properties: &[("facing", "south"), ("segment_amount", "2")],
4959 },
4960 weight: 1i32,
4961 },
4962 WeightedBlockState {
4963 data: BlockStateData {
4964 block: &vanilla_blocks::LEAF_LITTER,
4965 properties: &[("facing", "west"), ("segment_amount", "2")],
4966 },
4967 weight: 1i32,
4968 },
4969 WeightedBlockState {
4970 data: BlockStateData {
4971 block: &vanilla_blocks::LEAF_LITTER,
4972 properties: &[("facing", "north"), ("segment_amount", "3")],
4973 },
4974 weight: 1i32,
4975 },
4976 WeightedBlockState {
4977 data: BlockStateData {
4978 block: &vanilla_blocks::LEAF_LITTER,
4979 properties: &[("facing", "east"), ("segment_amount", "3")],
4980 },
4981 weight: 1i32,
4982 },
4983 WeightedBlockState {
4984 data: BlockStateData {
4985 block: &vanilla_blocks::LEAF_LITTER,
4986 properties: &[("facing", "south"), ("segment_amount", "3")],
4987 },
4988 weight: 1i32,
4989 },
4990 WeightedBlockState {
4991 data: BlockStateData {
4992 block: &vanilla_blocks::LEAF_LITTER,
4993 properties: &[("facing", "west"), ("segment_amount", "3")],
4994 },
4995 weight: 1i32,
4996 },
4997 ],
4998 },
4999 schedule_tick: false,
5000 }),
5001 id: OnceLock::new(),
5002});
5003pub static LUSH_CAVES_CLAY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5004 key: Identifier::vanilla_static("lush_caves_clay"),
5005 kind: ConfiguredFeatureKind::RandomBooleanSelector(RandomBooleanSelectorConfiguration {
5006 feature_true: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5007 feature: ConfiguredFeatureRef::Reference(
5008 &crate::vanilla_configured_features::CLAY_WITH_DRIPLEAVES,
5009 ),
5010 placement: vec![],
5011 })),
5012 feature_false: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5013 feature: ConfiguredFeatureRef::Reference(
5014 &crate::vanilla_configured_features::CLAY_POOL_WITH_DRIPLEAVES,
5015 ),
5016 placement: vec![],
5017 })),
5018 }),
5019 id: OnceLock::new(),
5020});
5021pub static MANGROVE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5022 key: Identifier::vanilla_static("mangrove"),
5023 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5024 trunk_provider: BlockStateProvider::Simple {
5025 state: BlockStateData {
5026 block: &vanilla_blocks::MANGROVE_LOG,
5027 properties: &[("axis", "y")],
5028 },
5029 },
5030 below_trunk_provider: BlockStateProvider::RuleBased {
5031 fallback: None,
5032 rules: vec![RuleBasedStateProviderRule {
5033 if_true: BlockPredicate::Not {
5034 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5035 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5036 offset: [0i32, 0i32, 0i32],
5037 }),
5038 },
5039 then: BlockStateProvider::Simple {
5040 state: BlockStateData {
5041 block: &vanilla_blocks::DIRT,
5042 properties: &[],
5043 },
5044 },
5045 }],
5046 },
5047 foliage_provider: BlockStateProvider::Simple {
5048 state: BlockStateData {
5049 block: &vanilla_blocks::MANGROVE_LEAVES,
5050 properties: &[
5051 ("distance", "7"),
5052 ("persistent", "false"),
5053 ("waterlogged", "false"),
5054 ],
5055 },
5056 },
5057 trunk_placer: TrunkPlacer::UpwardsBranching(UpwardsBranchingTrunkPlacer {
5058 base_height: 2i32,
5059 height_rand_a: 1i32,
5060 height_rand_b: 4i32,
5061 extra_branch_steps: IntProvider::Uniform {
5062 min_inclusive: 1i32,
5063 max_inclusive: 4i32,
5064 },
5065 extra_branch_length: IntProvider::Uniform {
5066 min_inclusive: 0i32,
5067 max_inclusive: 1i32,
5068 },
5069 place_branch_per_log_probability: 0.5f32,
5070 can_grow_through: Identifier::vanilla_static("mangrove_logs_can_grow_through"),
5071 }),
5072 foliage_placer: FoliagePlacer::RandomSpread(RandomSpreadFoliagePlacer {
5073 radius: IntProvider::Constant(3i32),
5074 offset: IntProvider::Constant(0i32),
5075 foliage_height: 2i32,
5076 leaf_placement_attempts: 70i32,
5077 }),
5078 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5079 limit: 2i32,
5080 lower_size: 0i32,
5081 upper_size: 2i32,
5082 min_clipped_height: None,
5083 }),
5084 decorators: vec![
5085 TreeDecorator::LeaveVine {
5086 probability: 0.125f32,
5087 },
5088 TreeDecorator::AttachedToLeaves(AttachedToLeavesDecorator {
5089 probability: 0.14f32,
5090 exclusion_radius_xz: 1i32,
5091 exclusion_radius_y: 0i32,
5092 required_empty_blocks: 2i32,
5093 block_provider: BlockStateProvider::RandomizedInt {
5094 property: "age".to_string(),
5095 source: Box::new(BlockStateProvider::Simple {
5096 state: BlockStateData {
5097 block: &vanilla_blocks::MANGROVE_PROPAGULE,
5098 properties: &[
5099 ("age", "0"),
5100 ("hanging", "true"),
5101 ("stage", "0"),
5102 ("waterlogged", "false"),
5103 ],
5104 },
5105 }),
5106 values: IntProvider::Uniform {
5107 min_inclusive: 0i32,
5108 max_inclusive: 4i32,
5109 },
5110 },
5111 directions: vec![Direction::Down],
5112 }),
5113 TreeDecorator::Beehive {
5114 probability: 0.01f32,
5115 },
5116 ],
5117 root_placer: Some(RootPlacer::Mangrove(MangroveRootPlacer {
5118 trunk_offset_y: IntProvider::Uniform {
5119 min_inclusive: 1i32,
5120 max_inclusive: 3i32,
5121 },
5122 root_provider: BlockStateProvider::Simple {
5123 state: BlockStateData {
5124 block: &vanilla_blocks::MANGROVE_ROOTS,
5125 properties: &[("waterlogged", "false")],
5126 },
5127 },
5128 above_root_placement: AboveRootPlacement {
5129 above_root_provider: BlockStateProvider::Simple {
5130 state: BlockStateData {
5131 block: &vanilla_blocks::MOSS_CARPET,
5132 properties: &[],
5133 },
5134 },
5135 above_root_placement_chance: 0.5f32,
5136 },
5137 mangrove_root_placement: MangroveRootPlacement {
5138 can_grow_through: Identifier::vanilla_static("mangrove_roots_can_grow_through"),
5139 muddy_roots_in: vec![
5140 Identifier::vanilla_static("mud"),
5141 Identifier::vanilla_static("muddy_mangrove_roots"),
5142 ],
5143 muddy_roots_provider: BlockStateProvider::Simple {
5144 state: BlockStateData {
5145 block: &vanilla_blocks::MUDDY_MANGROVE_ROOTS,
5146 properties: &[("axis", "y")],
5147 },
5148 },
5149 max_root_width: 8i32,
5150 max_root_length: 15i32,
5151 random_skew_chance: 0.2f32,
5152 },
5153 })),
5154 ignore_vines: true,
5155 }),
5156 id: OnceLock::new(),
5157});
5158pub static MANGROVE_VEGETATION: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5159 key: Identifier::vanilla_static("mangrove_vegetation"),
5160 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
5161 features: vec![WeightedPlacedFeature {
5162 chance: 0.85f32,
5163 feature: PlacedFeatureRef::Reference(
5164 &crate::vanilla_placed_features::TALL_MANGROVE_CHECKED,
5165 ),
5166 }],
5167 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::MANGROVE_CHECKED),
5168 }),
5169 id: OnceLock::new(),
5170});
5171pub static MEADOW_TREES: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5172 key: Identifier::vanilla_static("meadow_trees"),
5173 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
5174 features: vec![WeightedPlacedFeature {
5175 chance: 0.5f32,
5176 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::FANCY_OAK_BEES),
5177 }],
5178 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::SUPER_BIRCH_BEES),
5179 }),
5180 id: OnceLock::new(),
5181});
5182pub static MEGA_JUNGLE_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5183 key: Identifier::vanilla_static("mega_jungle_tree"),
5184 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5185 trunk_provider: BlockStateProvider::Simple {
5186 state: BlockStateData {
5187 block: &vanilla_blocks::JUNGLE_LOG,
5188 properties: &[("axis", "y")],
5189 },
5190 },
5191 below_trunk_provider: BlockStateProvider::RuleBased {
5192 fallback: None,
5193 rules: vec![RuleBasedStateProviderRule {
5194 if_true: BlockPredicate::Not {
5195 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5196 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5197 offset: [0i32, 0i32, 0i32],
5198 }),
5199 },
5200 then: BlockStateProvider::Simple {
5201 state: BlockStateData {
5202 block: &vanilla_blocks::DIRT,
5203 properties: &[],
5204 },
5205 },
5206 }],
5207 },
5208 foliage_provider: BlockStateProvider::Simple {
5209 state: BlockStateData {
5210 block: &vanilla_blocks::JUNGLE_LEAVES,
5211 properties: &[
5212 ("distance", "7"),
5213 ("persistent", "false"),
5214 ("waterlogged", "false"),
5215 ],
5216 },
5217 },
5218 trunk_placer: TrunkPlacer::MegaJungle(TrunkPlacerBase {
5219 base_height: 10i32,
5220 height_rand_a: 2i32,
5221 height_rand_b: 19i32,
5222 }),
5223 foliage_placer: FoliagePlacer::Jungle(BlobFoliagePlacer {
5224 radius: IntProvider::Constant(2i32),
5225 offset: IntProvider::Constant(0i32),
5226 height: IntProvider::Constant(2i32),
5227 }),
5228 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5229 limit: 1i32,
5230 lower_size: 1i32,
5231 upper_size: 2i32,
5232 min_clipped_height: None,
5233 }),
5234 decorators: vec![
5235 TreeDecorator::TrunkVine,
5236 TreeDecorator::LeaveVine {
5237 probability: 0.25f32,
5238 },
5239 ],
5240 root_placer: None,
5241 ignore_vines: false,
5242 }),
5243 id: OnceLock::new(),
5244});
5245pub static MEGA_PINE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5246 key: Identifier::vanilla_static("mega_pine"),
5247 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5248 trunk_provider: BlockStateProvider::Simple {
5249 state: BlockStateData {
5250 block: &vanilla_blocks::SPRUCE_LOG,
5251 properties: &[("axis", "y")],
5252 },
5253 },
5254 below_trunk_provider: BlockStateProvider::RuleBased {
5255 fallback: None,
5256 rules: vec![RuleBasedStateProviderRule {
5257 if_true: BlockPredicate::Not {
5258 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5259 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5260 offset: [0i32, 0i32, 0i32],
5261 }),
5262 },
5263 then: BlockStateProvider::Simple {
5264 state: BlockStateData {
5265 block: &vanilla_blocks::DIRT,
5266 properties: &[],
5267 },
5268 },
5269 }],
5270 },
5271 foliage_provider: BlockStateProvider::Simple {
5272 state: BlockStateData {
5273 block: &vanilla_blocks::SPRUCE_LEAVES,
5274 properties: &[
5275 ("distance", "7"),
5276 ("persistent", "false"),
5277 ("waterlogged", "false"),
5278 ],
5279 },
5280 },
5281 trunk_placer: TrunkPlacer::Giant(TrunkPlacerBase {
5282 base_height: 13i32,
5283 height_rand_a: 2i32,
5284 height_rand_b: 14i32,
5285 }),
5286 foliage_placer: FoliagePlacer::MegaPine(MegaPineFoliagePlacer {
5287 radius: IntProvider::Constant(0i32),
5288 offset: IntProvider::Constant(0i32),
5289 crown_height: IntProvider::Uniform {
5290 min_inclusive: 3i32,
5291 max_inclusive: 7i32,
5292 },
5293 }),
5294 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5295 limit: 1i32,
5296 lower_size: 1i32,
5297 upper_size: 2i32,
5298 min_clipped_height: None,
5299 }),
5300 decorators: vec![TreeDecorator::AlterGround {
5301 provider: BlockStateProvider::RuleBased {
5302 fallback: None,
5303 rules: vec![RuleBasedStateProviderRule {
5304 if_true: BlockPredicate::MatchingBlockTag {
5305 tag: Identifier::vanilla_static("beneath_tree_podzol_replaceable"),
5306 offset: [0i32, 0i32, 0i32],
5307 },
5308 then: BlockStateProvider::Simple {
5309 state: BlockStateData {
5310 block: &vanilla_blocks::PODZOL,
5311 properties: &[("snowy", "false")],
5312 },
5313 },
5314 }],
5315 },
5316 }],
5317 root_placer: None,
5318 ignore_vines: false,
5319 }),
5320 id: OnceLock::new(),
5321});
5322pub static MEGA_SPRUCE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5323 key: Identifier::vanilla_static("mega_spruce"),
5324 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5325 trunk_provider: BlockStateProvider::Simple {
5326 state: BlockStateData {
5327 block: &vanilla_blocks::SPRUCE_LOG,
5328 properties: &[("axis", "y")],
5329 },
5330 },
5331 below_trunk_provider: BlockStateProvider::RuleBased {
5332 fallback: None,
5333 rules: vec![RuleBasedStateProviderRule {
5334 if_true: BlockPredicate::Not {
5335 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5336 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5337 offset: [0i32, 0i32, 0i32],
5338 }),
5339 },
5340 then: BlockStateProvider::Simple {
5341 state: BlockStateData {
5342 block: &vanilla_blocks::DIRT,
5343 properties: &[],
5344 },
5345 },
5346 }],
5347 },
5348 foliage_provider: BlockStateProvider::Simple {
5349 state: BlockStateData {
5350 block: &vanilla_blocks::SPRUCE_LEAVES,
5351 properties: &[
5352 ("distance", "7"),
5353 ("persistent", "false"),
5354 ("waterlogged", "false"),
5355 ],
5356 },
5357 },
5358 trunk_placer: TrunkPlacer::Giant(TrunkPlacerBase {
5359 base_height: 13i32,
5360 height_rand_a: 2i32,
5361 height_rand_b: 14i32,
5362 }),
5363 foliage_placer: FoliagePlacer::MegaPine(MegaPineFoliagePlacer {
5364 radius: IntProvider::Constant(0i32),
5365 offset: IntProvider::Constant(0i32),
5366 crown_height: IntProvider::Uniform {
5367 min_inclusive: 13i32,
5368 max_inclusive: 17i32,
5369 },
5370 }),
5371 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5372 limit: 1i32,
5373 lower_size: 1i32,
5374 upper_size: 2i32,
5375 min_clipped_height: None,
5376 }),
5377 decorators: vec![TreeDecorator::AlterGround {
5378 provider: BlockStateProvider::RuleBased {
5379 fallback: None,
5380 rules: vec![RuleBasedStateProviderRule {
5381 if_true: BlockPredicate::MatchingBlockTag {
5382 tag: Identifier::vanilla_static("beneath_tree_podzol_replaceable"),
5383 offset: [0i32, 0i32, 0i32],
5384 },
5385 then: BlockStateProvider::Simple {
5386 state: BlockStateData {
5387 block: &vanilla_blocks::PODZOL,
5388 properties: &[("snowy", "false")],
5389 },
5390 },
5391 }],
5392 },
5393 }],
5394 root_placer: None,
5395 ignore_vines: false,
5396 }),
5397 id: OnceLock::new(),
5398});
5399pub static MELON: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5400 key: Identifier::vanilla_static("melon"),
5401 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
5402 to_place: BlockStateProvider::Simple {
5403 state: BlockStateData {
5404 block: &vanilla_blocks::MELON,
5405 properties: &[],
5406 },
5407 },
5408 schedule_tick: false,
5409 }),
5410 id: OnceLock::new(),
5411});
5412pub static MONSTER_ROOM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5413 key: Identifier::vanilla_static("monster_room"),
5414 kind: ConfiguredFeatureKind::MonsterRoom,
5415 id: OnceLock::new(),
5416});
5417pub static MOSS_PATCH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5418 key: Identifier::vanilla_static("moss_patch"),
5419 kind: ConfiguredFeatureKind::VegetationPatch(VegetationPatchConfiguration {
5420 replaceable: Identifier::vanilla_static("moss_replaceable"),
5421 ground_state: BlockStateProvider::Simple {
5422 state: BlockStateData {
5423 block: &vanilla_blocks::MOSS_BLOCK,
5424 properties: &[],
5425 },
5426 },
5427 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5428 feature: ConfiguredFeatureRef::Reference(
5429 &crate::vanilla_configured_features::MOSS_VEGETATION,
5430 ),
5431 placement: vec![],
5432 })),
5433 surface: VerticalSurface::Floor,
5434 depth: IntProvider::Constant(1i32),
5435 extra_bottom_block_chance: 0f32,
5436 vertical_range: 5i32,
5437 vegetation_chance: 0.8f32,
5438 xz_radius: IntProvider::Uniform {
5439 min_inclusive: 4i32,
5440 max_inclusive: 7i32,
5441 },
5442 extra_edge_column_chance: 0.3f32,
5443 }),
5444 id: OnceLock::new(),
5445});
5446pub static MOSS_PATCH_BONEMEAL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5447 key: Identifier::vanilla_static("moss_patch_bonemeal"),
5448 kind: ConfiguredFeatureKind::VegetationPatch(VegetationPatchConfiguration {
5449 replaceable: Identifier::vanilla_static("moss_replaceable"),
5450 ground_state: BlockStateProvider::Simple {
5451 state: BlockStateData {
5452 block: &vanilla_blocks::MOSS_BLOCK,
5453 properties: &[],
5454 },
5455 },
5456 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5457 feature: ConfiguredFeatureRef::Reference(
5458 &crate::vanilla_configured_features::MOSS_VEGETATION,
5459 ),
5460 placement: vec![],
5461 })),
5462 surface: VerticalSurface::Floor,
5463 depth: IntProvider::Constant(1i32),
5464 extra_bottom_block_chance: 0f32,
5465 vertical_range: 5i32,
5466 vegetation_chance: 0.6f32,
5467 xz_radius: IntProvider::Uniform {
5468 min_inclusive: 1i32,
5469 max_inclusive: 2i32,
5470 },
5471 extra_edge_column_chance: 0.75f32,
5472 }),
5473 id: OnceLock::new(),
5474});
5475pub static MOSS_PATCH_CEILING: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5476 key: Identifier::vanilla_static("moss_patch_ceiling"),
5477 kind: ConfiguredFeatureKind::VegetationPatch(VegetationPatchConfiguration {
5478 replaceable: Identifier::vanilla_static("moss_replaceable"),
5479 ground_state: BlockStateProvider::Simple {
5480 state: BlockStateData {
5481 block: &vanilla_blocks::MOSS_BLOCK,
5482 properties: &[],
5483 },
5484 },
5485 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5486 feature: ConfiguredFeatureRef::Reference(
5487 &crate::vanilla_configured_features::CAVE_VINE_IN_MOSS,
5488 ),
5489 placement: vec![],
5490 })),
5491 surface: VerticalSurface::Ceiling,
5492 depth: IntProvider::Uniform {
5493 min_inclusive: 1i32,
5494 max_inclusive: 2i32,
5495 },
5496 extra_bottom_block_chance: 0f32,
5497 vertical_range: 5i32,
5498 vegetation_chance: 0.08f32,
5499 xz_radius: IntProvider::Uniform {
5500 min_inclusive: 4i32,
5501 max_inclusive: 7i32,
5502 },
5503 extra_edge_column_chance: 0.3f32,
5504 }),
5505 id: OnceLock::new(),
5506});
5507pub static MOSS_VEGETATION: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5508 key: Identifier::vanilla_static("moss_vegetation"),
5509 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
5510 to_place: BlockStateProvider::Weighted {
5511 entries: vec![
5512 WeightedBlockState {
5513 data: BlockStateData {
5514 block: &vanilla_blocks::FLOWERING_AZALEA,
5515 properties: &[],
5516 },
5517 weight: 4i32,
5518 },
5519 WeightedBlockState {
5520 data: BlockStateData {
5521 block: &vanilla_blocks::AZALEA,
5522 properties: &[],
5523 },
5524 weight: 7i32,
5525 },
5526 WeightedBlockState {
5527 data: BlockStateData {
5528 block: &vanilla_blocks::MOSS_CARPET,
5529 properties: &[],
5530 },
5531 weight: 25i32,
5532 },
5533 WeightedBlockState {
5534 data: BlockStateData {
5535 block: &vanilla_blocks::SHORT_GRASS,
5536 properties: &[],
5537 },
5538 weight: 50i32,
5539 },
5540 WeightedBlockState {
5541 data: BlockStateData {
5542 block: &vanilla_blocks::TALL_GRASS,
5543 properties: &[("half", "lower")],
5544 },
5545 weight: 10i32,
5546 },
5547 ],
5548 },
5549 schedule_tick: false,
5550 }),
5551 id: OnceLock::new(),
5552});
5553pub static MUSHROOM_ISLAND_VEGETATION: LazyLock<ConfiguredFeature> =
5554 LazyLock::new(|| ConfiguredFeature {
5555 key: Identifier::vanilla_static("mushroom_island_vegetation"),
5556 kind: ConfiguredFeatureKind::RandomBooleanSelector(RandomBooleanSelectorConfiguration {
5557 feature_true: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5558 feature: ConfiguredFeatureRef::Reference(
5559 &crate::vanilla_configured_features::HUGE_RED_MUSHROOM,
5560 ),
5561 placement: vec![],
5562 })),
5563 feature_false: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
5564 feature: ConfiguredFeatureRef::Reference(
5565 &crate::vanilla_configured_features::HUGE_BROWN_MUSHROOM,
5566 ),
5567 placement: vec![],
5568 })),
5569 }),
5570 id: OnceLock::new(),
5571 });
5572pub static NETHER_SPROUTS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5573 key: Identifier::vanilla_static("nether_sprouts"),
5574 kind: ConfiguredFeatureKind::NetherForestVegetation(NetherForestVegetationConfiguration {
5575 state_provider: BlockStateProvider::Simple {
5576 state: BlockStateData {
5577 block: &vanilla_blocks::NETHER_SPROUTS,
5578 properties: &[],
5579 },
5580 },
5581 spread_width: 8i32,
5582 spread_height: 4i32,
5583 }),
5584 id: OnceLock::new(),
5585});
5586pub static NETHER_SPROUTS_BONEMEAL: LazyLock<ConfiguredFeature> =
5587 LazyLock::new(|| ConfiguredFeature {
5588 key: Identifier::vanilla_static("nether_sprouts_bonemeal"),
5589 kind: ConfiguredFeatureKind::NetherForestVegetation(NetherForestVegetationConfiguration {
5590 state_provider: BlockStateProvider::Simple {
5591 state: BlockStateData {
5592 block: &vanilla_blocks::NETHER_SPROUTS,
5593 properties: &[],
5594 },
5595 },
5596 spread_width: 3i32,
5597 spread_height: 1i32,
5598 }),
5599 id: OnceLock::new(),
5600 });
5601pub static OAK: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5602 key: Identifier::vanilla_static("oak"),
5603 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5604 trunk_provider: BlockStateProvider::Simple {
5605 state: BlockStateData {
5606 block: &vanilla_blocks::OAK_LOG,
5607 properties: &[("axis", "y")],
5608 },
5609 },
5610 below_trunk_provider: BlockStateProvider::RuleBased {
5611 fallback: None,
5612 rules: vec![RuleBasedStateProviderRule {
5613 if_true: BlockPredicate::Not {
5614 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5615 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5616 offset: [0i32, 0i32, 0i32],
5617 }),
5618 },
5619 then: BlockStateProvider::Simple {
5620 state: BlockStateData {
5621 block: &vanilla_blocks::DIRT,
5622 properties: &[],
5623 },
5624 },
5625 }],
5626 },
5627 foliage_provider: BlockStateProvider::Simple {
5628 state: BlockStateData {
5629 block: &vanilla_blocks::OAK_LEAVES,
5630 properties: &[
5631 ("distance", "7"),
5632 ("persistent", "false"),
5633 ("waterlogged", "false"),
5634 ],
5635 },
5636 },
5637 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
5638 base_height: 4i32,
5639 height_rand_a: 2i32,
5640 height_rand_b: 0i32,
5641 }),
5642 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
5643 radius: IntProvider::Constant(2i32),
5644 offset: IntProvider::Constant(0i32),
5645 height: IntProvider::Constant(3i32),
5646 }),
5647 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5648 limit: 1i32,
5649 lower_size: 0i32,
5650 upper_size: 1i32,
5651 min_clipped_height: None,
5652 }),
5653 decorators: vec![],
5654 root_placer: None,
5655 ignore_vines: true,
5656 }),
5657 id: OnceLock::new(),
5658});
5659pub static OAK_BEES_0002_LEAF_LITTER: LazyLock<ConfiguredFeature> =
5660 LazyLock::new(|| ConfiguredFeature {
5661 key: Identifier::vanilla_static("oak_bees_0002_leaf_litter"),
5662 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5663 trunk_provider: BlockStateProvider::Simple {
5664 state: BlockStateData {
5665 block: &vanilla_blocks::OAK_LOG,
5666 properties: &[("axis", "y")],
5667 },
5668 },
5669 below_trunk_provider: BlockStateProvider::RuleBased {
5670 fallback: None,
5671 rules: vec![RuleBasedStateProviderRule {
5672 if_true: BlockPredicate::Not {
5673 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5674 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5675 offset: [0i32, 0i32, 0i32],
5676 }),
5677 },
5678 then: BlockStateProvider::Simple {
5679 state: BlockStateData {
5680 block: &vanilla_blocks::DIRT,
5681 properties: &[],
5682 },
5683 },
5684 }],
5685 },
5686 foliage_provider: BlockStateProvider::Simple {
5687 state: BlockStateData {
5688 block: &vanilla_blocks::OAK_LEAVES,
5689 properties: &[
5690 ("distance", "7"),
5691 ("persistent", "false"),
5692 ("waterlogged", "false"),
5693 ],
5694 },
5695 },
5696 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
5697 base_height: 4i32,
5698 height_rand_a: 2i32,
5699 height_rand_b: 0i32,
5700 }),
5701 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
5702 radius: IntProvider::Constant(2i32),
5703 offset: IntProvider::Constant(0i32),
5704 height: IntProvider::Constant(3i32),
5705 }),
5706 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5707 limit: 1i32,
5708 lower_size: 0i32,
5709 upper_size: 1i32,
5710 min_clipped_height: None,
5711 }),
5712 decorators: vec![
5713 TreeDecorator::Beehive {
5714 probability: 0.002f32,
5715 },
5716 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
5717 block_state_provider: BlockStateProvider::Weighted {
5718 entries: vec![
5719 WeightedBlockState {
5720 data: BlockStateData {
5721 block: &vanilla_blocks::LEAF_LITTER,
5722 properties: &[("facing", "north"), ("segment_amount", "1")],
5723 },
5724 weight: 1i32,
5725 },
5726 WeightedBlockState {
5727 data: BlockStateData {
5728 block: &vanilla_blocks::LEAF_LITTER,
5729 properties: &[("facing", "east"), ("segment_amount", "1")],
5730 },
5731 weight: 1i32,
5732 },
5733 WeightedBlockState {
5734 data: BlockStateData {
5735 block: &vanilla_blocks::LEAF_LITTER,
5736 properties: &[("facing", "south"), ("segment_amount", "1")],
5737 },
5738 weight: 1i32,
5739 },
5740 WeightedBlockState {
5741 data: BlockStateData {
5742 block: &vanilla_blocks::LEAF_LITTER,
5743 properties: &[("facing", "west"), ("segment_amount", "1")],
5744 },
5745 weight: 1i32,
5746 },
5747 WeightedBlockState {
5748 data: BlockStateData {
5749 block: &vanilla_blocks::LEAF_LITTER,
5750 properties: &[("facing", "north"), ("segment_amount", "2")],
5751 },
5752 weight: 1i32,
5753 },
5754 WeightedBlockState {
5755 data: BlockStateData {
5756 block: &vanilla_blocks::LEAF_LITTER,
5757 properties: &[("facing", "east"), ("segment_amount", "2")],
5758 },
5759 weight: 1i32,
5760 },
5761 WeightedBlockState {
5762 data: BlockStateData {
5763 block: &vanilla_blocks::LEAF_LITTER,
5764 properties: &[("facing", "south"), ("segment_amount", "2")],
5765 },
5766 weight: 1i32,
5767 },
5768 WeightedBlockState {
5769 data: BlockStateData {
5770 block: &vanilla_blocks::LEAF_LITTER,
5771 properties: &[("facing", "west"), ("segment_amount", "2")],
5772 },
5773 weight: 1i32,
5774 },
5775 WeightedBlockState {
5776 data: BlockStateData {
5777 block: &vanilla_blocks::LEAF_LITTER,
5778 properties: &[("facing", "north"), ("segment_amount", "3")],
5779 },
5780 weight: 1i32,
5781 },
5782 WeightedBlockState {
5783 data: BlockStateData {
5784 block: &vanilla_blocks::LEAF_LITTER,
5785 properties: &[("facing", "east"), ("segment_amount", "3")],
5786 },
5787 weight: 1i32,
5788 },
5789 WeightedBlockState {
5790 data: BlockStateData {
5791 block: &vanilla_blocks::LEAF_LITTER,
5792 properties: &[("facing", "south"), ("segment_amount", "3")],
5793 },
5794 weight: 1i32,
5795 },
5796 WeightedBlockState {
5797 data: BlockStateData {
5798 block: &vanilla_blocks::LEAF_LITTER,
5799 properties: &[("facing", "west"), ("segment_amount", "3")],
5800 },
5801 weight: 1i32,
5802 },
5803 ],
5804 },
5805 tries: 96i32,
5806 radius: 4i32,
5807 height: 2i32,
5808 }),
5809 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
5810 block_state_provider: BlockStateProvider::Weighted {
5811 entries: vec![
5812 WeightedBlockState {
5813 data: BlockStateData {
5814 block: &vanilla_blocks::LEAF_LITTER,
5815 properties: &[("facing", "north"), ("segment_amount", "1")],
5816 },
5817 weight: 1i32,
5818 },
5819 WeightedBlockState {
5820 data: BlockStateData {
5821 block: &vanilla_blocks::LEAF_LITTER,
5822 properties: &[("facing", "east"), ("segment_amount", "1")],
5823 },
5824 weight: 1i32,
5825 },
5826 WeightedBlockState {
5827 data: BlockStateData {
5828 block: &vanilla_blocks::LEAF_LITTER,
5829 properties: &[("facing", "south"), ("segment_amount", "1")],
5830 },
5831 weight: 1i32,
5832 },
5833 WeightedBlockState {
5834 data: BlockStateData {
5835 block: &vanilla_blocks::LEAF_LITTER,
5836 properties: &[("facing", "west"), ("segment_amount", "1")],
5837 },
5838 weight: 1i32,
5839 },
5840 WeightedBlockState {
5841 data: BlockStateData {
5842 block: &vanilla_blocks::LEAF_LITTER,
5843 properties: &[("facing", "north"), ("segment_amount", "2")],
5844 },
5845 weight: 1i32,
5846 },
5847 WeightedBlockState {
5848 data: BlockStateData {
5849 block: &vanilla_blocks::LEAF_LITTER,
5850 properties: &[("facing", "east"), ("segment_amount", "2")],
5851 },
5852 weight: 1i32,
5853 },
5854 WeightedBlockState {
5855 data: BlockStateData {
5856 block: &vanilla_blocks::LEAF_LITTER,
5857 properties: &[("facing", "south"), ("segment_amount", "2")],
5858 },
5859 weight: 1i32,
5860 },
5861 WeightedBlockState {
5862 data: BlockStateData {
5863 block: &vanilla_blocks::LEAF_LITTER,
5864 properties: &[("facing", "west"), ("segment_amount", "2")],
5865 },
5866 weight: 1i32,
5867 },
5868 WeightedBlockState {
5869 data: BlockStateData {
5870 block: &vanilla_blocks::LEAF_LITTER,
5871 properties: &[("facing", "north"), ("segment_amount", "3")],
5872 },
5873 weight: 1i32,
5874 },
5875 WeightedBlockState {
5876 data: BlockStateData {
5877 block: &vanilla_blocks::LEAF_LITTER,
5878 properties: &[("facing", "east"), ("segment_amount", "3")],
5879 },
5880 weight: 1i32,
5881 },
5882 WeightedBlockState {
5883 data: BlockStateData {
5884 block: &vanilla_blocks::LEAF_LITTER,
5885 properties: &[("facing", "south"), ("segment_amount", "3")],
5886 },
5887 weight: 1i32,
5888 },
5889 WeightedBlockState {
5890 data: BlockStateData {
5891 block: &vanilla_blocks::LEAF_LITTER,
5892 properties: &[("facing", "west"), ("segment_amount", "3")],
5893 },
5894 weight: 1i32,
5895 },
5896 WeightedBlockState {
5897 data: BlockStateData {
5898 block: &vanilla_blocks::LEAF_LITTER,
5899 properties: &[("facing", "north"), ("segment_amount", "4")],
5900 },
5901 weight: 1i32,
5902 },
5903 WeightedBlockState {
5904 data: BlockStateData {
5905 block: &vanilla_blocks::LEAF_LITTER,
5906 properties: &[("facing", "east"), ("segment_amount", "4")],
5907 },
5908 weight: 1i32,
5909 },
5910 WeightedBlockState {
5911 data: BlockStateData {
5912 block: &vanilla_blocks::LEAF_LITTER,
5913 properties: &[("facing", "south"), ("segment_amount", "4")],
5914 },
5915 weight: 1i32,
5916 },
5917 WeightedBlockState {
5918 data: BlockStateData {
5919 block: &vanilla_blocks::LEAF_LITTER,
5920 properties: &[("facing", "west"), ("segment_amount", "4")],
5921 },
5922 weight: 1i32,
5923 },
5924 ],
5925 },
5926 tries: 150i32,
5927 radius: 2i32,
5928 height: 2i32,
5929 }),
5930 ],
5931 root_placer: None,
5932 ignore_vines: true,
5933 }),
5934 id: OnceLock::new(),
5935 });
5936pub static OAK_BEES_002: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5937 key: Identifier::vanilla_static("oak_bees_002"),
5938 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5939 trunk_provider: BlockStateProvider::Simple {
5940 state: BlockStateData {
5941 block: &vanilla_blocks::OAK_LOG,
5942 properties: &[("axis", "y")],
5943 },
5944 },
5945 below_trunk_provider: BlockStateProvider::RuleBased {
5946 fallback: None,
5947 rules: vec![RuleBasedStateProviderRule {
5948 if_true: BlockPredicate::Not {
5949 predicate: Box::new(BlockPredicate::MatchingBlockTag {
5950 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
5951 offset: [0i32, 0i32, 0i32],
5952 }),
5953 },
5954 then: BlockStateProvider::Simple {
5955 state: BlockStateData {
5956 block: &vanilla_blocks::DIRT,
5957 properties: &[],
5958 },
5959 },
5960 }],
5961 },
5962 foliage_provider: BlockStateProvider::Simple {
5963 state: BlockStateData {
5964 block: &vanilla_blocks::OAK_LEAVES,
5965 properties: &[
5966 ("distance", "7"),
5967 ("persistent", "false"),
5968 ("waterlogged", "false"),
5969 ],
5970 },
5971 },
5972 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
5973 base_height: 4i32,
5974 height_rand_a: 2i32,
5975 height_rand_b: 0i32,
5976 }),
5977 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
5978 radius: IntProvider::Constant(2i32),
5979 offset: IntProvider::Constant(0i32),
5980 height: IntProvider::Constant(3i32),
5981 }),
5982 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
5983 limit: 1i32,
5984 lower_size: 0i32,
5985 upper_size: 1i32,
5986 min_clipped_height: None,
5987 }),
5988 decorators: vec![TreeDecorator::Beehive {
5989 probability: 0.02f32,
5990 }],
5991 root_placer: None,
5992 ignore_vines: true,
5993 }),
5994 id: OnceLock::new(),
5995});
5996pub static OAK_BEES_005: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
5997 key: Identifier::vanilla_static("oak_bees_005"),
5998 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
5999 trunk_provider: BlockStateProvider::Simple {
6000 state: BlockStateData {
6001 block: &vanilla_blocks::OAK_LOG,
6002 properties: &[("axis", "y")],
6003 },
6004 },
6005 below_trunk_provider: BlockStateProvider::RuleBased {
6006 fallback: None,
6007 rules: vec![RuleBasedStateProviderRule {
6008 if_true: BlockPredicate::Not {
6009 predicate: Box::new(BlockPredicate::MatchingBlockTag {
6010 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
6011 offset: [0i32, 0i32, 0i32],
6012 }),
6013 },
6014 then: BlockStateProvider::Simple {
6015 state: BlockStateData {
6016 block: &vanilla_blocks::DIRT,
6017 properties: &[],
6018 },
6019 },
6020 }],
6021 },
6022 foliage_provider: BlockStateProvider::Simple {
6023 state: BlockStateData {
6024 block: &vanilla_blocks::OAK_LEAVES,
6025 properties: &[
6026 ("distance", "7"),
6027 ("persistent", "false"),
6028 ("waterlogged", "false"),
6029 ],
6030 },
6031 },
6032 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
6033 base_height: 4i32,
6034 height_rand_a: 2i32,
6035 height_rand_b: 0i32,
6036 }),
6037 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
6038 radius: IntProvider::Constant(2i32),
6039 offset: IntProvider::Constant(0i32),
6040 height: IntProvider::Constant(3i32),
6041 }),
6042 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
6043 limit: 1i32,
6044 lower_size: 0i32,
6045 upper_size: 1i32,
6046 min_clipped_height: None,
6047 }),
6048 decorators: vec![TreeDecorator::Beehive {
6049 probability: 0.05f32,
6050 }],
6051 root_placer: None,
6052 ignore_vines: true,
6053 }),
6054 id: OnceLock::new(),
6055});
6056pub static OAK_LEAF_LITTER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6057 key: Identifier::vanilla_static("oak_leaf_litter"),
6058 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
6059 trunk_provider: BlockStateProvider::Simple {
6060 state: BlockStateData {
6061 block: &vanilla_blocks::OAK_LOG,
6062 properties: &[("axis", "y")],
6063 },
6064 },
6065 below_trunk_provider: BlockStateProvider::RuleBased {
6066 fallback: None,
6067 rules: vec![RuleBasedStateProviderRule {
6068 if_true: BlockPredicate::Not {
6069 predicate: Box::new(BlockPredicate::MatchingBlockTag {
6070 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
6071 offset: [0i32, 0i32, 0i32],
6072 }),
6073 },
6074 then: BlockStateProvider::Simple {
6075 state: BlockStateData {
6076 block: &vanilla_blocks::DIRT,
6077 properties: &[],
6078 },
6079 },
6080 }],
6081 },
6082 foliage_provider: BlockStateProvider::Simple {
6083 state: BlockStateData {
6084 block: &vanilla_blocks::OAK_LEAVES,
6085 properties: &[
6086 ("distance", "7"),
6087 ("persistent", "false"),
6088 ("waterlogged", "false"),
6089 ],
6090 },
6091 },
6092 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
6093 base_height: 4i32,
6094 height_rand_a: 2i32,
6095 height_rand_b: 0i32,
6096 }),
6097 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
6098 radius: IntProvider::Constant(2i32),
6099 offset: IntProvider::Constant(0i32),
6100 height: IntProvider::Constant(3i32),
6101 }),
6102 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
6103 limit: 1i32,
6104 lower_size: 0i32,
6105 upper_size: 1i32,
6106 min_clipped_height: None,
6107 }),
6108 decorators: vec![
6109 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
6110 block_state_provider: BlockStateProvider::Weighted {
6111 entries: vec![
6112 WeightedBlockState {
6113 data: BlockStateData {
6114 block: &vanilla_blocks::LEAF_LITTER,
6115 properties: &[("facing", "north"), ("segment_amount", "1")],
6116 },
6117 weight: 1i32,
6118 },
6119 WeightedBlockState {
6120 data: BlockStateData {
6121 block: &vanilla_blocks::LEAF_LITTER,
6122 properties: &[("facing", "east"), ("segment_amount", "1")],
6123 },
6124 weight: 1i32,
6125 },
6126 WeightedBlockState {
6127 data: BlockStateData {
6128 block: &vanilla_blocks::LEAF_LITTER,
6129 properties: &[("facing", "south"), ("segment_amount", "1")],
6130 },
6131 weight: 1i32,
6132 },
6133 WeightedBlockState {
6134 data: BlockStateData {
6135 block: &vanilla_blocks::LEAF_LITTER,
6136 properties: &[("facing", "west"), ("segment_amount", "1")],
6137 },
6138 weight: 1i32,
6139 },
6140 WeightedBlockState {
6141 data: BlockStateData {
6142 block: &vanilla_blocks::LEAF_LITTER,
6143 properties: &[("facing", "north"), ("segment_amount", "2")],
6144 },
6145 weight: 1i32,
6146 },
6147 WeightedBlockState {
6148 data: BlockStateData {
6149 block: &vanilla_blocks::LEAF_LITTER,
6150 properties: &[("facing", "east"), ("segment_amount", "2")],
6151 },
6152 weight: 1i32,
6153 },
6154 WeightedBlockState {
6155 data: BlockStateData {
6156 block: &vanilla_blocks::LEAF_LITTER,
6157 properties: &[("facing", "south"), ("segment_amount", "2")],
6158 },
6159 weight: 1i32,
6160 },
6161 WeightedBlockState {
6162 data: BlockStateData {
6163 block: &vanilla_blocks::LEAF_LITTER,
6164 properties: &[("facing", "west"), ("segment_amount", "2")],
6165 },
6166 weight: 1i32,
6167 },
6168 WeightedBlockState {
6169 data: BlockStateData {
6170 block: &vanilla_blocks::LEAF_LITTER,
6171 properties: &[("facing", "north"), ("segment_amount", "3")],
6172 },
6173 weight: 1i32,
6174 },
6175 WeightedBlockState {
6176 data: BlockStateData {
6177 block: &vanilla_blocks::LEAF_LITTER,
6178 properties: &[("facing", "east"), ("segment_amount", "3")],
6179 },
6180 weight: 1i32,
6181 },
6182 WeightedBlockState {
6183 data: BlockStateData {
6184 block: &vanilla_blocks::LEAF_LITTER,
6185 properties: &[("facing", "south"), ("segment_amount", "3")],
6186 },
6187 weight: 1i32,
6188 },
6189 WeightedBlockState {
6190 data: BlockStateData {
6191 block: &vanilla_blocks::LEAF_LITTER,
6192 properties: &[("facing", "west"), ("segment_amount", "3")],
6193 },
6194 weight: 1i32,
6195 },
6196 ],
6197 },
6198 tries: 96i32,
6199 radius: 4i32,
6200 height: 2i32,
6201 }),
6202 TreeDecorator::PlaceOnGround(PlaceOnGroundDecorator {
6203 block_state_provider: BlockStateProvider::Weighted {
6204 entries: vec![
6205 WeightedBlockState {
6206 data: BlockStateData {
6207 block: &vanilla_blocks::LEAF_LITTER,
6208 properties: &[("facing", "north"), ("segment_amount", "1")],
6209 },
6210 weight: 1i32,
6211 },
6212 WeightedBlockState {
6213 data: BlockStateData {
6214 block: &vanilla_blocks::LEAF_LITTER,
6215 properties: &[("facing", "east"), ("segment_amount", "1")],
6216 },
6217 weight: 1i32,
6218 },
6219 WeightedBlockState {
6220 data: BlockStateData {
6221 block: &vanilla_blocks::LEAF_LITTER,
6222 properties: &[("facing", "south"), ("segment_amount", "1")],
6223 },
6224 weight: 1i32,
6225 },
6226 WeightedBlockState {
6227 data: BlockStateData {
6228 block: &vanilla_blocks::LEAF_LITTER,
6229 properties: &[("facing", "west"), ("segment_amount", "1")],
6230 },
6231 weight: 1i32,
6232 },
6233 WeightedBlockState {
6234 data: BlockStateData {
6235 block: &vanilla_blocks::LEAF_LITTER,
6236 properties: &[("facing", "north"), ("segment_amount", "2")],
6237 },
6238 weight: 1i32,
6239 },
6240 WeightedBlockState {
6241 data: BlockStateData {
6242 block: &vanilla_blocks::LEAF_LITTER,
6243 properties: &[("facing", "east"), ("segment_amount", "2")],
6244 },
6245 weight: 1i32,
6246 },
6247 WeightedBlockState {
6248 data: BlockStateData {
6249 block: &vanilla_blocks::LEAF_LITTER,
6250 properties: &[("facing", "south"), ("segment_amount", "2")],
6251 },
6252 weight: 1i32,
6253 },
6254 WeightedBlockState {
6255 data: BlockStateData {
6256 block: &vanilla_blocks::LEAF_LITTER,
6257 properties: &[("facing", "west"), ("segment_amount", "2")],
6258 },
6259 weight: 1i32,
6260 },
6261 WeightedBlockState {
6262 data: BlockStateData {
6263 block: &vanilla_blocks::LEAF_LITTER,
6264 properties: &[("facing", "north"), ("segment_amount", "3")],
6265 },
6266 weight: 1i32,
6267 },
6268 WeightedBlockState {
6269 data: BlockStateData {
6270 block: &vanilla_blocks::LEAF_LITTER,
6271 properties: &[("facing", "east"), ("segment_amount", "3")],
6272 },
6273 weight: 1i32,
6274 },
6275 WeightedBlockState {
6276 data: BlockStateData {
6277 block: &vanilla_blocks::LEAF_LITTER,
6278 properties: &[("facing", "south"), ("segment_amount", "3")],
6279 },
6280 weight: 1i32,
6281 },
6282 WeightedBlockState {
6283 data: BlockStateData {
6284 block: &vanilla_blocks::LEAF_LITTER,
6285 properties: &[("facing", "west"), ("segment_amount", "3")],
6286 },
6287 weight: 1i32,
6288 },
6289 WeightedBlockState {
6290 data: BlockStateData {
6291 block: &vanilla_blocks::LEAF_LITTER,
6292 properties: &[("facing", "north"), ("segment_amount", "4")],
6293 },
6294 weight: 1i32,
6295 },
6296 WeightedBlockState {
6297 data: BlockStateData {
6298 block: &vanilla_blocks::LEAF_LITTER,
6299 properties: &[("facing", "east"), ("segment_amount", "4")],
6300 },
6301 weight: 1i32,
6302 },
6303 WeightedBlockState {
6304 data: BlockStateData {
6305 block: &vanilla_blocks::LEAF_LITTER,
6306 properties: &[("facing", "south"), ("segment_amount", "4")],
6307 },
6308 weight: 1i32,
6309 },
6310 WeightedBlockState {
6311 data: BlockStateData {
6312 block: &vanilla_blocks::LEAF_LITTER,
6313 properties: &[("facing", "west"), ("segment_amount", "4")],
6314 },
6315 weight: 1i32,
6316 },
6317 ],
6318 },
6319 tries: 150i32,
6320 radius: 2i32,
6321 height: 2i32,
6322 }),
6323 ],
6324 root_placer: None,
6325 ignore_vines: true,
6326 }),
6327 id: OnceLock::new(),
6328});
6329pub static ORE_ANCIENT_DEBRIS_LARGE: LazyLock<ConfiguredFeature> =
6330 LazyLock::new(|| ConfiguredFeature {
6331 key: Identifier::vanilla_static("ore_ancient_debris_large"),
6332 kind: ConfiguredFeatureKind::ScatteredOre(OreConfiguration {
6333 targets: vec![OreTarget {
6334 target: RuleTest::TagMatch {
6335 tag: Identifier::vanilla_static("base_stone_nether"),
6336 },
6337 state: BlockStateData {
6338 block: &vanilla_blocks::ANCIENT_DEBRIS,
6339 properties: &[],
6340 },
6341 }],
6342 size: 3i32,
6343 discard_chance_on_air_exposure: 1f32,
6344 }),
6345 id: OnceLock::new(),
6346 });
6347pub static ORE_ANCIENT_DEBRIS_SMALL: LazyLock<ConfiguredFeature> =
6348 LazyLock::new(|| ConfiguredFeature {
6349 key: Identifier::vanilla_static("ore_ancient_debris_small"),
6350 kind: ConfiguredFeatureKind::ScatteredOre(OreConfiguration {
6351 targets: vec![OreTarget {
6352 target: RuleTest::TagMatch {
6353 tag: Identifier::vanilla_static("base_stone_nether"),
6354 },
6355 state: BlockStateData {
6356 block: &vanilla_blocks::ANCIENT_DEBRIS,
6357 properties: &[],
6358 },
6359 }],
6360 size: 2i32,
6361 discard_chance_on_air_exposure: 1f32,
6362 }),
6363 id: OnceLock::new(),
6364 });
6365pub static ORE_ANDESITE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6366 key: Identifier::vanilla_static("ore_andesite"),
6367 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6368 targets: vec![OreTarget {
6369 target: RuleTest::TagMatch {
6370 tag: Identifier::vanilla_static("base_stone_overworld"),
6371 },
6372 state: BlockStateData {
6373 block: &vanilla_blocks::ANDESITE,
6374 properties: &[],
6375 },
6376 }],
6377 size: 64i32,
6378 discard_chance_on_air_exposure: 0f32,
6379 }),
6380 id: OnceLock::new(),
6381});
6382pub static ORE_BLACKSTONE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6383 key: Identifier::vanilla_static("ore_blackstone"),
6384 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6385 targets: vec![OreTarget {
6386 target: RuleTest::BlockMatch {
6387 block: &vanilla_blocks::NETHERRACK,
6388 },
6389 state: BlockStateData {
6390 block: &vanilla_blocks::BLACKSTONE,
6391 properties: &[],
6392 },
6393 }],
6394 size: 33i32,
6395 discard_chance_on_air_exposure: 0f32,
6396 }),
6397 id: OnceLock::new(),
6398});
6399pub static ORE_CLAY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6400 key: Identifier::vanilla_static("ore_clay"),
6401 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6402 targets: vec![OreTarget {
6403 target: RuleTest::TagMatch {
6404 tag: Identifier::vanilla_static("base_stone_overworld"),
6405 },
6406 state: BlockStateData {
6407 block: &vanilla_blocks::CLAY,
6408 properties: &[],
6409 },
6410 }],
6411 size: 33i32,
6412 discard_chance_on_air_exposure: 0f32,
6413 }),
6414 id: OnceLock::new(),
6415});
6416pub static ORE_COAL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6417 key: Identifier::vanilla_static("ore_coal"),
6418 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6419 targets: vec![
6420 OreTarget {
6421 target: RuleTest::TagMatch {
6422 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6423 },
6424 state: BlockStateData {
6425 block: &vanilla_blocks::COAL_ORE,
6426 properties: &[],
6427 },
6428 },
6429 OreTarget {
6430 target: RuleTest::TagMatch {
6431 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6432 },
6433 state: BlockStateData {
6434 block: &vanilla_blocks::DEEPSLATE_COAL_ORE,
6435 properties: &[],
6436 },
6437 },
6438 ],
6439 size: 17i32,
6440 discard_chance_on_air_exposure: 0f32,
6441 }),
6442 id: OnceLock::new(),
6443});
6444pub static ORE_COAL_BURIED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6445 key: Identifier::vanilla_static("ore_coal_buried"),
6446 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6447 targets: vec![
6448 OreTarget {
6449 target: RuleTest::TagMatch {
6450 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6451 },
6452 state: BlockStateData {
6453 block: &vanilla_blocks::COAL_ORE,
6454 properties: &[],
6455 },
6456 },
6457 OreTarget {
6458 target: RuleTest::TagMatch {
6459 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6460 },
6461 state: BlockStateData {
6462 block: &vanilla_blocks::DEEPSLATE_COAL_ORE,
6463 properties: &[],
6464 },
6465 },
6466 ],
6467 size: 17i32,
6468 discard_chance_on_air_exposure: 0.5f32,
6469 }),
6470 id: OnceLock::new(),
6471});
6472pub static ORE_COPPER_LARGE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6473 key: Identifier::vanilla_static("ore_copper_large"),
6474 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6475 targets: vec![
6476 OreTarget {
6477 target: RuleTest::TagMatch {
6478 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6479 },
6480 state: BlockStateData {
6481 block: &vanilla_blocks::COPPER_ORE,
6482 properties: &[],
6483 },
6484 },
6485 OreTarget {
6486 target: RuleTest::TagMatch {
6487 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6488 },
6489 state: BlockStateData {
6490 block: &vanilla_blocks::DEEPSLATE_COPPER_ORE,
6491 properties: &[],
6492 },
6493 },
6494 ],
6495 size: 20i32,
6496 discard_chance_on_air_exposure: 0f32,
6497 }),
6498 id: OnceLock::new(),
6499});
6500pub static ORE_COPPER_SMALL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6501 key: Identifier::vanilla_static("ore_copper_small"),
6502 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6503 targets: vec![
6504 OreTarget {
6505 target: RuleTest::TagMatch {
6506 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6507 },
6508 state: BlockStateData {
6509 block: &vanilla_blocks::COPPER_ORE,
6510 properties: &[],
6511 },
6512 },
6513 OreTarget {
6514 target: RuleTest::TagMatch {
6515 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6516 },
6517 state: BlockStateData {
6518 block: &vanilla_blocks::DEEPSLATE_COPPER_ORE,
6519 properties: &[],
6520 },
6521 },
6522 ],
6523 size: 10i32,
6524 discard_chance_on_air_exposure: 0f32,
6525 }),
6526 id: OnceLock::new(),
6527});
6528pub static ORE_DIAMOND_BURIED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6529 key: Identifier::vanilla_static("ore_diamond_buried"),
6530 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6531 targets: vec![
6532 OreTarget {
6533 target: RuleTest::TagMatch {
6534 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6535 },
6536 state: BlockStateData {
6537 block: &vanilla_blocks::DIAMOND_ORE,
6538 properties: &[],
6539 },
6540 },
6541 OreTarget {
6542 target: RuleTest::TagMatch {
6543 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6544 },
6545 state: BlockStateData {
6546 block: &vanilla_blocks::DEEPSLATE_DIAMOND_ORE,
6547 properties: &[],
6548 },
6549 },
6550 ],
6551 size: 8i32,
6552 discard_chance_on_air_exposure: 1f32,
6553 }),
6554 id: OnceLock::new(),
6555});
6556pub static ORE_DIAMOND_LARGE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6557 key: Identifier::vanilla_static("ore_diamond_large"),
6558 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6559 targets: vec![
6560 OreTarget {
6561 target: RuleTest::TagMatch {
6562 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6563 },
6564 state: BlockStateData {
6565 block: &vanilla_blocks::DIAMOND_ORE,
6566 properties: &[],
6567 },
6568 },
6569 OreTarget {
6570 target: RuleTest::TagMatch {
6571 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6572 },
6573 state: BlockStateData {
6574 block: &vanilla_blocks::DEEPSLATE_DIAMOND_ORE,
6575 properties: &[],
6576 },
6577 },
6578 ],
6579 size: 12i32,
6580 discard_chance_on_air_exposure: 0.7f32,
6581 }),
6582 id: OnceLock::new(),
6583});
6584pub static ORE_DIAMOND_MEDIUM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6585 key: Identifier::vanilla_static("ore_diamond_medium"),
6586 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6587 targets: vec![
6588 OreTarget {
6589 target: RuleTest::TagMatch {
6590 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6591 },
6592 state: BlockStateData {
6593 block: &vanilla_blocks::DIAMOND_ORE,
6594 properties: &[],
6595 },
6596 },
6597 OreTarget {
6598 target: RuleTest::TagMatch {
6599 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6600 },
6601 state: BlockStateData {
6602 block: &vanilla_blocks::DEEPSLATE_DIAMOND_ORE,
6603 properties: &[],
6604 },
6605 },
6606 ],
6607 size: 8i32,
6608 discard_chance_on_air_exposure: 0.5f32,
6609 }),
6610 id: OnceLock::new(),
6611});
6612pub static ORE_DIAMOND_SMALL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6613 key: Identifier::vanilla_static("ore_diamond_small"),
6614 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6615 targets: vec![
6616 OreTarget {
6617 target: RuleTest::TagMatch {
6618 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6619 },
6620 state: BlockStateData {
6621 block: &vanilla_blocks::DIAMOND_ORE,
6622 properties: &[],
6623 },
6624 },
6625 OreTarget {
6626 target: RuleTest::TagMatch {
6627 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6628 },
6629 state: BlockStateData {
6630 block: &vanilla_blocks::DEEPSLATE_DIAMOND_ORE,
6631 properties: &[],
6632 },
6633 },
6634 ],
6635 size: 4i32,
6636 discard_chance_on_air_exposure: 0.5f32,
6637 }),
6638 id: OnceLock::new(),
6639});
6640pub static ORE_DIORITE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6641 key: Identifier::vanilla_static("ore_diorite"),
6642 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6643 targets: vec![OreTarget {
6644 target: RuleTest::TagMatch {
6645 tag: Identifier::vanilla_static("base_stone_overworld"),
6646 },
6647 state: BlockStateData {
6648 block: &vanilla_blocks::DIORITE,
6649 properties: &[],
6650 },
6651 }],
6652 size: 64i32,
6653 discard_chance_on_air_exposure: 0f32,
6654 }),
6655 id: OnceLock::new(),
6656});
6657pub static ORE_DIRT: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6658 key: Identifier::vanilla_static("ore_dirt"),
6659 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6660 targets: vec![OreTarget {
6661 target: RuleTest::TagMatch {
6662 tag: Identifier::vanilla_static("base_stone_overworld"),
6663 },
6664 state: BlockStateData {
6665 block: &vanilla_blocks::DIRT,
6666 properties: &[],
6667 },
6668 }],
6669 size: 33i32,
6670 discard_chance_on_air_exposure: 0f32,
6671 }),
6672 id: OnceLock::new(),
6673});
6674pub static ORE_EMERALD: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6675 key: Identifier::vanilla_static("ore_emerald"),
6676 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6677 targets: vec![
6678 OreTarget {
6679 target: RuleTest::TagMatch {
6680 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6681 },
6682 state: BlockStateData {
6683 block: &vanilla_blocks::EMERALD_ORE,
6684 properties: &[],
6685 },
6686 },
6687 OreTarget {
6688 target: RuleTest::TagMatch {
6689 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6690 },
6691 state: BlockStateData {
6692 block: &vanilla_blocks::DEEPSLATE_EMERALD_ORE,
6693 properties: &[],
6694 },
6695 },
6696 ],
6697 size: 3i32,
6698 discard_chance_on_air_exposure: 0f32,
6699 }),
6700 id: OnceLock::new(),
6701});
6702pub static ORE_GOLD: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6703 key: Identifier::vanilla_static("ore_gold"),
6704 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6705 targets: vec![
6706 OreTarget {
6707 target: RuleTest::TagMatch {
6708 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6709 },
6710 state: BlockStateData {
6711 block: &vanilla_blocks::GOLD_ORE,
6712 properties: &[],
6713 },
6714 },
6715 OreTarget {
6716 target: RuleTest::TagMatch {
6717 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6718 },
6719 state: BlockStateData {
6720 block: &vanilla_blocks::DEEPSLATE_GOLD_ORE,
6721 properties: &[],
6722 },
6723 },
6724 ],
6725 size: 9i32,
6726 discard_chance_on_air_exposure: 0f32,
6727 }),
6728 id: OnceLock::new(),
6729});
6730pub static ORE_GOLD_BURIED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6731 key: Identifier::vanilla_static("ore_gold_buried"),
6732 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6733 targets: vec![
6734 OreTarget {
6735 target: RuleTest::TagMatch {
6736 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6737 },
6738 state: BlockStateData {
6739 block: &vanilla_blocks::GOLD_ORE,
6740 properties: &[],
6741 },
6742 },
6743 OreTarget {
6744 target: RuleTest::TagMatch {
6745 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6746 },
6747 state: BlockStateData {
6748 block: &vanilla_blocks::DEEPSLATE_GOLD_ORE,
6749 properties: &[],
6750 },
6751 },
6752 ],
6753 size: 9i32,
6754 discard_chance_on_air_exposure: 0.5f32,
6755 }),
6756 id: OnceLock::new(),
6757});
6758pub static ORE_GRANITE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6759 key: Identifier::vanilla_static("ore_granite"),
6760 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6761 targets: vec![OreTarget {
6762 target: RuleTest::TagMatch {
6763 tag: Identifier::vanilla_static("base_stone_overworld"),
6764 },
6765 state: BlockStateData {
6766 block: &vanilla_blocks::GRANITE,
6767 properties: &[],
6768 },
6769 }],
6770 size: 64i32,
6771 discard_chance_on_air_exposure: 0f32,
6772 }),
6773 id: OnceLock::new(),
6774});
6775pub static ORE_GRAVEL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6776 key: Identifier::vanilla_static("ore_gravel"),
6777 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6778 targets: vec![OreTarget {
6779 target: RuleTest::TagMatch {
6780 tag: Identifier::vanilla_static("base_stone_overworld"),
6781 },
6782 state: BlockStateData {
6783 block: &vanilla_blocks::GRAVEL,
6784 properties: &[],
6785 },
6786 }],
6787 size: 33i32,
6788 discard_chance_on_air_exposure: 0f32,
6789 }),
6790 id: OnceLock::new(),
6791});
6792pub static ORE_GRAVEL_NETHER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6793 key: Identifier::vanilla_static("ore_gravel_nether"),
6794 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6795 targets: vec![OreTarget {
6796 target: RuleTest::BlockMatch {
6797 block: &vanilla_blocks::NETHERRACK,
6798 },
6799 state: BlockStateData {
6800 block: &vanilla_blocks::GRAVEL,
6801 properties: &[],
6802 },
6803 }],
6804 size: 33i32,
6805 discard_chance_on_air_exposure: 0f32,
6806 }),
6807 id: OnceLock::new(),
6808});
6809pub static ORE_INFESTED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6810 key: Identifier::vanilla_static("ore_infested"),
6811 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6812 targets: vec![
6813 OreTarget {
6814 target: RuleTest::TagMatch {
6815 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6816 },
6817 state: BlockStateData {
6818 block: &vanilla_blocks::INFESTED_STONE,
6819 properties: &[],
6820 },
6821 },
6822 OreTarget {
6823 target: RuleTest::TagMatch {
6824 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6825 },
6826 state: BlockStateData {
6827 block: &vanilla_blocks::INFESTED_DEEPSLATE,
6828 properties: &[("axis", "y")],
6829 },
6830 },
6831 ],
6832 size: 9i32,
6833 discard_chance_on_air_exposure: 0f32,
6834 }),
6835 id: OnceLock::new(),
6836});
6837pub static ORE_IRON: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6838 key: Identifier::vanilla_static("ore_iron"),
6839 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6840 targets: vec![
6841 OreTarget {
6842 target: RuleTest::TagMatch {
6843 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6844 },
6845 state: BlockStateData {
6846 block: &vanilla_blocks::IRON_ORE,
6847 properties: &[],
6848 },
6849 },
6850 OreTarget {
6851 target: RuleTest::TagMatch {
6852 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6853 },
6854 state: BlockStateData {
6855 block: &vanilla_blocks::DEEPSLATE_IRON_ORE,
6856 properties: &[],
6857 },
6858 },
6859 ],
6860 size: 9i32,
6861 discard_chance_on_air_exposure: 0f32,
6862 }),
6863 id: OnceLock::new(),
6864});
6865pub static ORE_IRON_SMALL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6866 key: Identifier::vanilla_static("ore_iron_small"),
6867 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6868 targets: vec![
6869 OreTarget {
6870 target: RuleTest::TagMatch {
6871 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6872 },
6873 state: BlockStateData {
6874 block: &vanilla_blocks::IRON_ORE,
6875 properties: &[],
6876 },
6877 },
6878 OreTarget {
6879 target: RuleTest::TagMatch {
6880 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6881 },
6882 state: BlockStateData {
6883 block: &vanilla_blocks::DEEPSLATE_IRON_ORE,
6884 properties: &[],
6885 },
6886 },
6887 ],
6888 size: 4i32,
6889 discard_chance_on_air_exposure: 0f32,
6890 }),
6891 id: OnceLock::new(),
6892});
6893pub static ORE_LAPIS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6894 key: Identifier::vanilla_static("ore_lapis"),
6895 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6896 targets: vec![
6897 OreTarget {
6898 target: RuleTest::TagMatch {
6899 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6900 },
6901 state: BlockStateData {
6902 block: &vanilla_blocks::LAPIS_ORE,
6903 properties: &[],
6904 },
6905 },
6906 OreTarget {
6907 target: RuleTest::TagMatch {
6908 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6909 },
6910 state: BlockStateData {
6911 block: &vanilla_blocks::DEEPSLATE_LAPIS_ORE,
6912 properties: &[],
6913 },
6914 },
6915 ],
6916 size: 7i32,
6917 discard_chance_on_air_exposure: 0f32,
6918 }),
6919 id: OnceLock::new(),
6920});
6921pub static ORE_LAPIS_BURIED: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6922 key: Identifier::vanilla_static("ore_lapis_buried"),
6923 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6924 targets: vec![
6925 OreTarget {
6926 target: RuleTest::TagMatch {
6927 tag: Identifier::vanilla_static("stone_ore_replaceables"),
6928 },
6929 state: BlockStateData {
6930 block: &vanilla_blocks::LAPIS_ORE,
6931 properties: &[],
6932 },
6933 },
6934 OreTarget {
6935 target: RuleTest::TagMatch {
6936 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
6937 },
6938 state: BlockStateData {
6939 block: &vanilla_blocks::DEEPSLATE_LAPIS_ORE,
6940 properties: &[],
6941 },
6942 },
6943 ],
6944 size: 7i32,
6945 discard_chance_on_air_exposure: 1f32,
6946 }),
6947 id: OnceLock::new(),
6948});
6949pub static ORE_MAGMA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6950 key: Identifier::vanilla_static("ore_magma"),
6951 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6952 targets: vec![OreTarget {
6953 target: RuleTest::BlockMatch {
6954 block: &vanilla_blocks::NETHERRACK,
6955 },
6956 state: BlockStateData {
6957 block: &vanilla_blocks::MAGMA_BLOCK,
6958 properties: &[],
6959 },
6960 }],
6961 size: 33i32,
6962 discard_chance_on_air_exposure: 0f32,
6963 }),
6964 id: OnceLock::new(),
6965});
6966pub static ORE_NETHER_GOLD: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6967 key: Identifier::vanilla_static("ore_nether_gold"),
6968 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6969 targets: vec![OreTarget {
6970 target: RuleTest::BlockMatch {
6971 block: &vanilla_blocks::NETHERRACK,
6972 },
6973 state: BlockStateData {
6974 block: &vanilla_blocks::NETHER_GOLD_ORE,
6975 properties: &[],
6976 },
6977 }],
6978 size: 10i32,
6979 discard_chance_on_air_exposure: 0f32,
6980 }),
6981 id: OnceLock::new(),
6982});
6983pub static ORE_QUARTZ: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
6984 key: Identifier::vanilla_static("ore_quartz"),
6985 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
6986 targets: vec![OreTarget {
6987 target: RuleTest::BlockMatch {
6988 block: &vanilla_blocks::NETHERRACK,
6989 },
6990 state: BlockStateData {
6991 block: &vanilla_blocks::NETHER_QUARTZ_ORE,
6992 properties: &[],
6993 },
6994 }],
6995 size: 14i32,
6996 discard_chance_on_air_exposure: 0f32,
6997 }),
6998 id: OnceLock::new(),
6999});
7000pub static ORE_REDSTONE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7001 key: Identifier::vanilla_static("ore_redstone"),
7002 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
7003 targets: vec![
7004 OreTarget {
7005 target: RuleTest::TagMatch {
7006 tag: Identifier::vanilla_static("stone_ore_replaceables"),
7007 },
7008 state: BlockStateData {
7009 block: &vanilla_blocks::REDSTONE_ORE,
7010 properties: &[("lit", "false")],
7011 },
7012 },
7013 OreTarget {
7014 target: RuleTest::TagMatch {
7015 tag: Identifier::vanilla_static("deepslate_ore_replaceables"),
7016 },
7017 state: BlockStateData {
7018 block: &vanilla_blocks::DEEPSLATE_REDSTONE_ORE,
7019 properties: &[("lit", "false")],
7020 },
7021 },
7022 ],
7023 size: 8i32,
7024 discard_chance_on_air_exposure: 0f32,
7025 }),
7026 id: OnceLock::new(),
7027});
7028pub static ORE_SOUL_SAND: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7029 key: Identifier::vanilla_static("ore_soul_sand"),
7030 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
7031 targets: vec![OreTarget {
7032 target: RuleTest::BlockMatch {
7033 block: &vanilla_blocks::NETHERRACK,
7034 },
7035 state: BlockStateData {
7036 block: &vanilla_blocks::SOUL_SAND,
7037 properties: &[],
7038 },
7039 }],
7040 size: 12i32,
7041 discard_chance_on_air_exposure: 0f32,
7042 }),
7043 id: OnceLock::new(),
7044});
7045pub static ORE_TUFF: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7046 key: Identifier::vanilla_static("ore_tuff"),
7047 kind: ConfiguredFeatureKind::Ore(OreConfiguration {
7048 targets: vec![OreTarget {
7049 target: RuleTest::TagMatch {
7050 tag: Identifier::vanilla_static("base_stone_overworld"),
7051 },
7052 state: BlockStateData {
7053 block: &vanilla_blocks::TUFF,
7054 properties: &[],
7055 },
7056 }],
7057 size: 64i32,
7058 discard_chance_on_air_exposure: 0f32,
7059 }),
7060 id: OnceLock::new(),
7061});
7062pub static PALE_FOREST_FLOWER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7063 key: Identifier::vanilla_static("pale_forest_flower"),
7064 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7065 to_place: BlockStateProvider::Simple {
7066 state: BlockStateData {
7067 block: &vanilla_blocks::CLOSED_EYEBLOSSOM,
7068 properties: &[],
7069 },
7070 },
7071 schedule_tick: true,
7072 }),
7073 id: OnceLock::new(),
7074});
7075pub static PALE_GARDEN_VEGETATION: LazyLock<ConfiguredFeature> =
7076 LazyLock::new(|| ConfiguredFeature {
7077 key: Identifier::vanilla_static("pale_garden_vegetation"),
7078 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
7079 features: vec![
7080 WeightedPlacedFeature {
7081 chance: 0.1f32,
7082 feature: PlacedFeatureRef::Reference(
7083 &crate::vanilla_placed_features::PALE_OAK_CREAKING_CHECKED,
7084 ),
7085 },
7086 WeightedPlacedFeature {
7087 chance: 0.9f32,
7088 feature: PlacedFeatureRef::Reference(
7089 &crate::vanilla_placed_features::PALE_OAK_CHECKED,
7090 ),
7091 },
7092 ],
7093 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::PALE_OAK_CHECKED),
7094 }),
7095 id: OnceLock::new(),
7096 });
7097pub static PALE_MOSS_PATCH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7098 key: Identifier::vanilla_static("pale_moss_patch"),
7099 kind: ConfiguredFeatureKind::VegetationPatch(VegetationPatchConfiguration {
7100 replaceable: Identifier::vanilla_static("moss_replaceable"),
7101 ground_state: BlockStateProvider::Simple {
7102 state: BlockStateData {
7103 block: &vanilla_blocks::PALE_MOSS_BLOCK,
7104 properties: &[],
7105 },
7106 },
7107 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
7108 feature: ConfiguredFeatureRef::Reference(
7109 &crate::vanilla_configured_features::PALE_MOSS_VEGETATION,
7110 ),
7111 placement: vec![],
7112 })),
7113 surface: VerticalSurface::Floor,
7114 depth: IntProvider::Constant(1i32),
7115 extra_bottom_block_chance: 0f32,
7116 vertical_range: 5i32,
7117 vegetation_chance: 0.3f32,
7118 xz_radius: IntProvider::Uniform {
7119 min_inclusive: 2i32,
7120 max_inclusive: 4i32,
7121 },
7122 extra_edge_column_chance: 0.75f32,
7123 }),
7124 id: OnceLock::new(),
7125});
7126pub static PALE_MOSS_PATCH_BONEMEAL: LazyLock<ConfiguredFeature> =
7127 LazyLock::new(|| ConfiguredFeature {
7128 key: Identifier::vanilla_static("pale_moss_patch_bonemeal"),
7129 kind: ConfiguredFeatureKind::VegetationPatch(VegetationPatchConfiguration {
7130 replaceable: Identifier::vanilla_static("moss_replaceable"),
7131 ground_state: BlockStateProvider::Simple {
7132 state: BlockStateData {
7133 block: &vanilla_blocks::PALE_MOSS_BLOCK,
7134 properties: &[],
7135 },
7136 },
7137 vegetation_feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
7138 feature: ConfiguredFeatureRef::Reference(
7139 &crate::vanilla_configured_features::PALE_MOSS_VEGETATION,
7140 ),
7141 placement: vec![],
7142 })),
7143 surface: VerticalSurface::Floor,
7144 depth: IntProvider::Constant(1i32),
7145 extra_bottom_block_chance: 0f32,
7146 vertical_range: 5i32,
7147 vegetation_chance: 0.6f32,
7148 xz_radius: IntProvider::Uniform {
7149 min_inclusive: 1i32,
7150 max_inclusive: 2i32,
7151 },
7152 extra_edge_column_chance: 0.75f32,
7153 }),
7154 id: OnceLock::new(),
7155 });
7156pub static PALE_MOSS_VEGETATION: LazyLock<ConfiguredFeature> =
7157 LazyLock::new(|| ConfiguredFeature {
7158 key: Identifier::vanilla_static("pale_moss_vegetation"),
7159 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7160 to_place: BlockStateProvider::Weighted {
7161 entries: vec![
7162 WeightedBlockState {
7163 data: BlockStateData {
7164 block: &vanilla_blocks::PALE_MOSS_CARPET,
7165 properties: &[
7166 ("bottom", "true"),
7167 ("east", "none"),
7168 ("north", "none"),
7169 ("south", "none"),
7170 ("west", "none"),
7171 ],
7172 },
7173 weight: 25i32,
7174 },
7175 WeightedBlockState {
7176 data: BlockStateData {
7177 block: &vanilla_blocks::SHORT_GRASS,
7178 properties: &[],
7179 },
7180 weight: 25i32,
7181 },
7182 WeightedBlockState {
7183 data: BlockStateData {
7184 block: &vanilla_blocks::TALL_GRASS,
7185 properties: &[("half", "lower")],
7186 },
7187 weight: 10i32,
7188 },
7189 ],
7190 },
7191 schedule_tick: false,
7192 }),
7193 id: OnceLock::new(),
7194 });
7195pub static PALE_OAK: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7196 key: Identifier::vanilla_static("pale_oak"),
7197 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
7198 trunk_provider: BlockStateProvider::Simple {
7199 state: BlockStateData {
7200 block: &vanilla_blocks::PALE_OAK_LOG,
7201 properties: &[("axis", "y")],
7202 },
7203 },
7204 below_trunk_provider: BlockStateProvider::RuleBased {
7205 fallback: None,
7206 rules: vec![RuleBasedStateProviderRule {
7207 if_true: BlockPredicate::Not {
7208 predicate: Box::new(BlockPredicate::MatchingBlockTag {
7209 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
7210 offset: [0i32, 0i32, 0i32],
7211 }),
7212 },
7213 then: BlockStateProvider::Simple {
7214 state: BlockStateData {
7215 block: &vanilla_blocks::DIRT,
7216 properties: &[],
7217 },
7218 },
7219 }],
7220 },
7221 foliage_provider: BlockStateProvider::Simple {
7222 state: BlockStateData {
7223 block: &vanilla_blocks::PALE_OAK_LEAVES,
7224 properties: &[
7225 ("distance", "7"),
7226 ("persistent", "false"),
7227 ("waterlogged", "false"),
7228 ],
7229 },
7230 },
7231 trunk_placer: TrunkPlacer::DarkOak(TrunkPlacerBase {
7232 base_height: 6i32,
7233 height_rand_a: 2i32,
7234 height_rand_b: 1i32,
7235 }),
7236 foliage_placer: FoliagePlacer::DarkOak(FoliagePlacerBase {
7237 radius: IntProvider::Constant(0i32),
7238 offset: IntProvider::Constant(0i32),
7239 }),
7240 minimum_size: FeatureSize::ThreeLayers(ThreeLayersFeatureSize {
7241 limit: 1i32,
7242 lower_size: 0i32,
7243 middle_size: 1i32,
7244 upper_limit: 1i32,
7245 upper_size: 2i32,
7246 min_clipped_height: None,
7247 }),
7248 decorators: vec![TreeDecorator::PaleMoss {
7249 leaves_probability: 0.15f32,
7250 trunk_probability: 0.4f32,
7251 ground_probability: 0.8f32,
7252 }],
7253 root_placer: None,
7254 ignore_vines: true,
7255 }),
7256 id: OnceLock::new(),
7257});
7258pub static PALE_OAK_BONEMEAL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7259 key: Identifier::vanilla_static("pale_oak_bonemeal"),
7260 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
7261 trunk_provider: BlockStateProvider::Simple {
7262 state: BlockStateData {
7263 block: &vanilla_blocks::PALE_OAK_LOG,
7264 properties: &[("axis", "y")],
7265 },
7266 },
7267 below_trunk_provider: BlockStateProvider::RuleBased {
7268 fallback: None,
7269 rules: vec![RuleBasedStateProviderRule {
7270 if_true: BlockPredicate::Not {
7271 predicate: Box::new(BlockPredicate::MatchingBlockTag {
7272 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
7273 offset: [0i32, 0i32, 0i32],
7274 }),
7275 },
7276 then: BlockStateProvider::Simple {
7277 state: BlockStateData {
7278 block: &vanilla_blocks::DIRT,
7279 properties: &[],
7280 },
7281 },
7282 }],
7283 },
7284 foliage_provider: BlockStateProvider::Simple {
7285 state: BlockStateData {
7286 block: &vanilla_blocks::PALE_OAK_LEAVES,
7287 properties: &[
7288 ("distance", "7"),
7289 ("persistent", "false"),
7290 ("waterlogged", "false"),
7291 ],
7292 },
7293 },
7294 trunk_placer: TrunkPlacer::DarkOak(TrunkPlacerBase {
7295 base_height: 6i32,
7296 height_rand_a: 2i32,
7297 height_rand_b: 1i32,
7298 }),
7299 foliage_placer: FoliagePlacer::DarkOak(FoliagePlacerBase {
7300 radius: IntProvider::Constant(0i32),
7301 offset: IntProvider::Constant(0i32),
7302 }),
7303 minimum_size: FeatureSize::ThreeLayers(ThreeLayersFeatureSize {
7304 limit: 1i32,
7305 lower_size: 0i32,
7306 middle_size: 1i32,
7307 upper_limit: 1i32,
7308 upper_size: 2i32,
7309 min_clipped_height: None,
7310 }),
7311 decorators: vec![],
7312 root_placer: None,
7313 ignore_vines: true,
7314 }),
7315 id: OnceLock::new(),
7316});
7317pub static PALE_OAK_CREAKING: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7318 key: Identifier::vanilla_static("pale_oak_creaking"),
7319 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
7320 trunk_provider: BlockStateProvider::Simple {
7321 state: BlockStateData {
7322 block: &vanilla_blocks::PALE_OAK_LOG,
7323 properties: &[("axis", "y")],
7324 },
7325 },
7326 below_trunk_provider: BlockStateProvider::RuleBased {
7327 fallback: None,
7328 rules: vec![RuleBasedStateProviderRule {
7329 if_true: BlockPredicate::Not {
7330 predicate: Box::new(BlockPredicate::MatchingBlockTag {
7331 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
7332 offset: [0i32, 0i32, 0i32],
7333 }),
7334 },
7335 then: BlockStateProvider::Simple {
7336 state: BlockStateData {
7337 block: &vanilla_blocks::DIRT,
7338 properties: &[],
7339 },
7340 },
7341 }],
7342 },
7343 foliage_provider: BlockStateProvider::Simple {
7344 state: BlockStateData {
7345 block: &vanilla_blocks::PALE_OAK_LEAVES,
7346 properties: &[
7347 ("distance", "7"),
7348 ("persistent", "false"),
7349 ("waterlogged", "false"),
7350 ],
7351 },
7352 },
7353 trunk_placer: TrunkPlacer::DarkOak(TrunkPlacerBase {
7354 base_height: 6i32,
7355 height_rand_a: 2i32,
7356 height_rand_b: 1i32,
7357 }),
7358 foliage_placer: FoliagePlacer::DarkOak(FoliagePlacerBase {
7359 radius: IntProvider::Constant(0i32),
7360 offset: IntProvider::Constant(0i32),
7361 }),
7362 minimum_size: FeatureSize::ThreeLayers(ThreeLayersFeatureSize {
7363 limit: 1i32,
7364 lower_size: 0i32,
7365 middle_size: 1i32,
7366 upper_limit: 1i32,
7367 upper_size: 2i32,
7368 min_clipped_height: None,
7369 }),
7370 decorators: vec![
7371 TreeDecorator::PaleMoss {
7372 leaves_probability: 0.15f32,
7373 trunk_probability: 0.4f32,
7374 ground_probability: 0.8f32,
7375 },
7376 TreeDecorator::CreakingHeart { probability: 1f32 },
7377 ],
7378 root_placer: None,
7379 ignore_vines: true,
7380 }),
7381 id: OnceLock::new(),
7382});
7383pub static PATCH_FIRE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7384 key: Identifier::vanilla_static("patch_fire"),
7385 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7386 to_place: BlockStateProvider::Simple {
7387 state: BlockStateData {
7388 block: &vanilla_blocks::FIRE,
7389 properties: &[
7390 ("age", "0"),
7391 ("east", "false"),
7392 ("north", "false"),
7393 ("south", "false"),
7394 ("up", "false"),
7395 ("west", "false"),
7396 ],
7397 },
7398 },
7399 schedule_tick: false,
7400 }),
7401 id: OnceLock::new(),
7402});
7403pub static PATCH_SOUL_FIRE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7404 key: Identifier::vanilla_static("patch_soul_fire"),
7405 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7406 to_place: BlockStateProvider::Simple {
7407 state: BlockStateData {
7408 block: &vanilla_blocks::SOUL_FIRE,
7409 properties: &[],
7410 },
7411 },
7412 schedule_tick: false,
7413 }),
7414 id: OnceLock::new(),
7415});
7416pub static PILE_HAY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7417 key: Identifier::vanilla_static("pile_hay"),
7418 kind: ConfiguredFeatureKind::BlockPile(BlockPileConfiguration {
7419 state_provider: BlockStateProvider::RotatedBlock {
7420 state: BlockStateData {
7421 block: &vanilla_blocks::HAY_BLOCK,
7422 properties: &[("axis", "y")],
7423 },
7424 },
7425 }),
7426 id: OnceLock::new(),
7427});
7428pub static PILE_ICE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7429 key: Identifier::vanilla_static("pile_ice"),
7430 kind: ConfiguredFeatureKind::BlockPile(BlockPileConfiguration {
7431 state_provider: BlockStateProvider::Weighted {
7432 entries: vec![
7433 WeightedBlockState {
7434 data: BlockStateData {
7435 block: &vanilla_blocks::BLUE_ICE,
7436 properties: &[],
7437 },
7438 weight: 1i32,
7439 },
7440 WeightedBlockState {
7441 data: BlockStateData {
7442 block: &vanilla_blocks::PACKED_ICE,
7443 properties: &[],
7444 },
7445 weight: 5i32,
7446 },
7447 ],
7448 },
7449 }),
7450 id: OnceLock::new(),
7451});
7452pub static PILE_MELON: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7453 key: Identifier::vanilla_static("pile_melon"),
7454 kind: ConfiguredFeatureKind::BlockPile(BlockPileConfiguration {
7455 state_provider: BlockStateProvider::Simple {
7456 state: BlockStateData {
7457 block: &vanilla_blocks::MELON,
7458 properties: &[],
7459 },
7460 },
7461 }),
7462 id: OnceLock::new(),
7463});
7464pub static PILE_PUMPKIN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7465 key: Identifier::vanilla_static("pile_pumpkin"),
7466 kind: ConfiguredFeatureKind::BlockPile(BlockPileConfiguration {
7467 state_provider: BlockStateProvider::Weighted {
7468 entries: vec![
7469 WeightedBlockState {
7470 data: BlockStateData {
7471 block: &vanilla_blocks::PUMPKIN,
7472 properties: &[],
7473 },
7474 weight: 19i32,
7475 },
7476 WeightedBlockState {
7477 data: BlockStateData {
7478 block: &vanilla_blocks::JACK_O_LANTERN,
7479 properties: &[("facing", "north")],
7480 },
7481 weight: 1i32,
7482 },
7483 ],
7484 },
7485 }),
7486 id: OnceLock::new(),
7487});
7488pub static PILE_SNOW: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7489 key: Identifier::vanilla_static("pile_snow"),
7490 kind: ConfiguredFeatureKind::BlockPile(BlockPileConfiguration {
7491 state_provider: BlockStateProvider::Simple {
7492 state: BlockStateData {
7493 block: &vanilla_blocks::SNOW,
7494 properties: &[("layers", "1")],
7495 },
7496 },
7497 }),
7498 id: OnceLock::new(),
7499});
7500pub static PINE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7501 key: Identifier::vanilla_static("pine"),
7502 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
7503 trunk_provider: BlockStateProvider::Simple {
7504 state: BlockStateData {
7505 block: &vanilla_blocks::SPRUCE_LOG,
7506 properties: &[("axis", "y")],
7507 },
7508 },
7509 below_trunk_provider: BlockStateProvider::RuleBased {
7510 fallback: None,
7511 rules: vec![RuleBasedStateProviderRule {
7512 if_true: BlockPredicate::Not {
7513 predicate: Box::new(BlockPredicate::MatchingBlockTag {
7514 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
7515 offset: [0i32, 0i32, 0i32],
7516 }),
7517 },
7518 then: BlockStateProvider::Simple {
7519 state: BlockStateData {
7520 block: &vanilla_blocks::DIRT,
7521 properties: &[],
7522 },
7523 },
7524 }],
7525 },
7526 foliage_provider: BlockStateProvider::Simple {
7527 state: BlockStateData {
7528 block: &vanilla_blocks::SPRUCE_LEAVES,
7529 properties: &[
7530 ("distance", "7"),
7531 ("persistent", "false"),
7532 ("waterlogged", "false"),
7533 ],
7534 },
7535 },
7536 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
7537 base_height: 6i32,
7538 height_rand_a: 4i32,
7539 height_rand_b: 0i32,
7540 }),
7541 foliage_placer: FoliagePlacer::Pine(PineFoliagePlacer {
7542 radius: IntProvider::Constant(1i32),
7543 offset: IntProvider::Constant(1i32),
7544 height: IntProvider::Uniform {
7545 min_inclusive: 3i32,
7546 max_inclusive: 4i32,
7547 },
7548 }),
7549 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
7550 limit: 2i32,
7551 lower_size: 0i32,
7552 upper_size: 2i32,
7553 min_clipped_height: None,
7554 }),
7555 decorators: vec![],
7556 root_placer: None,
7557 ignore_vines: true,
7558 }),
7559 id: OnceLock::new(),
7560});
7561pub static POINTED_DRIPSTONE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7562 key: Identifier::vanilla_static("pointed_dripstone"),
7563 kind: ConfiguredFeatureKind::SimpleRandomSelector(SimpleRandomSelectorConfiguration {
7564 features: vec![
7565 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
7566 feature: ConfiguredFeatureRef::Inline(Box::new(
7567 ConfiguredFeatureKind::PointedDripstone(PointedDripstoneConfiguration {
7568 chance_of_taller_dripstone: 0.2f32,
7569 chance_of_directional_spread: 0.7f32,
7570 chance_of_spread_radius2: 0.5f32,
7571 chance_of_spread_radius3: 0.5f32,
7572 }),
7573 )),
7574 placement: vec![
7575 PlacementModifier::EnvironmentScan {
7576 direction_of_search: Direction::Down,
7577 target_condition: BlockPredicate::Solid {
7578 offset: [0i32, 0i32, 0i32],
7579 },
7580 allowed_search_condition: Some(BlockPredicate::AnyOf {
7581 predicates: vec![
7582 BlockPredicate::MatchingBlockTag {
7583 tag: Identifier::vanilla_static("air"),
7584 offset: [0i32, 0i32, 0i32],
7585 },
7586 BlockPredicate::MatchingBlocks {
7587 blocks: BlockRefList(vec![&vanilla_blocks::WATER]),
7588 offset: [0i32, 0i32, 0i32],
7589 },
7590 ],
7591 }),
7592 max_steps: 12i32,
7593 },
7594 PlacementModifier::RandomOffset {
7595 xz_spread: IntProvider::Constant(0i32),
7596 y_spread: IntProvider::Constant(1i32),
7597 },
7598 ],
7599 })),
7600 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
7601 feature: ConfiguredFeatureRef::Inline(Box::new(
7602 ConfiguredFeatureKind::PointedDripstone(PointedDripstoneConfiguration {
7603 chance_of_taller_dripstone: 0.2f32,
7604 chance_of_directional_spread: 0.7f32,
7605 chance_of_spread_radius2: 0.5f32,
7606 chance_of_spread_radius3: 0.5f32,
7607 }),
7608 )),
7609 placement: vec![
7610 PlacementModifier::EnvironmentScan {
7611 direction_of_search: Direction::Up,
7612 target_condition: BlockPredicate::Solid {
7613 offset: [0i32, 0i32, 0i32],
7614 },
7615 allowed_search_condition: Some(BlockPredicate::AnyOf {
7616 predicates: vec![
7617 BlockPredicate::MatchingBlockTag {
7618 tag: Identifier::vanilla_static("air"),
7619 offset: [0i32, 0i32, 0i32],
7620 },
7621 BlockPredicate::MatchingBlocks {
7622 blocks: BlockRefList(vec![&vanilla_blocks::WATER]),
7623 offset: [0i32, 0i32, 0i32],
7624 },
7625 ],
7626 }),
7627 max_steps: 12i32,
7628 },
7629 PlacementModifier::RandomOffset {
7630 xz_spread: IntProvider::Constant(0i32),
7631 y_spread: IntProvider::Constant(-1i32),
7632 },
7633 ],
7634 })),
7635 ],
7636 }),
7637 id: OnceLock::new(),
7638});
7639pub static PUMPKIN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7640 key: Identifier::vanilla_static("pumpkin"),
7641 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7642 to_place: BlockStateProvider::Simple {
7643 state: BlockStateData {
7644 block: &vanilla_blocks::PUMPKIN,
7645 properties: &[],
7646 },
7647 },
7648 schedule_tick: false,
7649 }),
7650 id: OnceLock::new(),
7651});
7652pub static RED_MUSHROOM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7653 key: Identifier::vanilla_static("red_mushroom"),
7654 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7655 to_place: BlockStateProvider::Simple {
7656 state: BlockStateData {
7657 block: &vanilla_blocks::RED_MUSHROOM,
7658 properties: &[],
7659 },
7660 },
7661 schedule_tick: false,
7662 }),
7663 id: OnceLock::new(),
7664});
7665pub static ROOTED_AZALEA_TREE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7666 key: Identifier::vanilla_static("rooted_azalea_tree"),
7667 kind: ConfiguredFeatureKind::RootSystem(RootSystemConfiguration {
7668 feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
7669 feature: ConfiguredFeatureRef::Reference(
7670 &crate::vanilla_configured_features::AZALEA_TREE,
7671 ),
7672 placement: vec![],
7673 })),
7674 required_vertical_space_for_tree: 3i32,
7675 root_radius: 3i32,
7676 root_placement_attempts: 20i32,
7677 root_column_max_height: 100i32,
7678 hanging_root_radius: 3i32,
7679 hanging_roots_vertical_span: 2i32,
7680 hanging_root_placement_attempts: 20i32,
7681 allowed_vertical_water_for_tree: 2i32,
7682 root_state_provider: BlockStateProvider::Simple {
7683 state: BlockStateData {
7684 block: &vanilla_blocks::ROOTED_DIRT,
7685 properties: &[],
7686 },
7687 },
7688 hanging_root_state_provider: BlockStateProvider::Simple {
7689 state: BlockStateData {
7690 block: &vanilla_blocks::HANGING_ROOTS,
7691 properties: &[("waterlogged", "false")],
7692 },
7693 },
7694 root_replaceable: Identifier::vanilla_static("azalea_root_replaceable"),
7695 allowed_tree_position: BlockPredicate::AllOf {
7696 predicates: vec![
7697 BlockPredicate::AnyOf {
7698 predicates: vec![
7699 BlockPredicate::MatchingBlockTag {
7700 tag: Identifier::vanilla_static("air"),
7701 offset: [0i32, 0i32, 0i32],
7702 },
7703 BlockPredicate::MatchingBlockTag {
7704 tag: Identifier::vanilla_static("replaceable_by_trees"),
7705 offset: [0i32, 0i32, 0i32],
7706 },
7707 ],
7708 },
7709 BlockPredicate::MatchingBlockTag {
7710 tag: Identifier::vanilla_static("azalea_grows_on"),
7711 offset: [0i32, -1i32, 0i32],
7712 },
7713 ],
7714 },
7715 }),
7716 id: OnceLock::new(),
7717});
7718pub static SCULK_PATCH_ANCIENT_CITY: LazyLock<ConfiguredFeature> =
7719 LazyLock::new(|| ConfiguredFeature {
7720 key: Identifier::vanilla_static("sculk_patch_ancient_city"),
7721 kind: ConfiguredFeatureKind::SculkPatch(SculkPatchConfiguration {
7722 charge_count: 10i32,
7723 amount_per_charge: 32i32,
7724 spread_attempts: 64i32,
7725 growth_rounds: 0i32,
7726 spread_rounds: 1i32,
7727 extra_rare_growths: IntProvider::Uniform {
7728 min_inclusive: 1i32,
7729 max_inclusive: 3i32,
7730 },
7731 catalyst_chance: 0.5f32,
7732 }),
7733 id: OnceLock::new(),
7734 });
7735pub static SCULK_PATCH_DEEP_DARK: LazyLock<ConfiguredFeature> =
7736 LazyLock::new(|| ConfiguredFeature {
7737 key: Identifier::vanilla_static("sculk_patch_deep_dark"),
7738 kind: ConfiguredFeatureKind::SculkPatch(SculkPatchConfiguration {
7739 charge_count: 10i32,
7740 amount_per_charge: 32i32,
7741 spread_attempts: 64i32,
7742 growth_rounds: 0i32,
7743 spread_rounds: 1i32,
7744 extra_rare_growths: IntProvider::Constant(0i32),
7745 catalyst_chance: 0.5f32,
7746 }),
7747 id: OnceLock::new(),
7748 });
7749pub static SCULK_VEIN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7750 key: Identifier::vanilla_static("sculk_vein"),
7751 kind: ConfiguredFeatureKind::MultifaceGrowth(MultifaceGrowthConfiguration {
7752 block: &vanilla_blocks::SCULK_VEIN,
7753 search_range: 20i32,
7754 can_place_on_floor: true,
7755 can_place_on_ceiling: true,
7756 can_place_on_wall: true,
7757 chance_of_spreading: 1f32,
7758 can_be_placed_on: vec![
7759 &vanilla_blocks::STONE,
7760 &vanilla_blocks::ANDESITE,
7761 &vanilla_blocks::DIORITE,
7762 &vanilla_blocks::GRANITE,
7763 &vanilla_blocks::DRIPSTONE_BLOCK,
7764 &vanilla_blocks::CALCITE,
7765 &vanilla_blocks::TUFF,
7766 &vanilla_blocks::DEEPSLATE,
7767 ],
7768 }),
7769 id: OnceLock::new(),
7770});
7771pub static SEA_PICKLE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7772 key: Identifier::vanilla_static("sea_pickle"),
7773 kind: ConfiguredFeatureKind::SeaPickle(SeaPickleConfiguration {
7774 count: IntProvider::Constant(20i32),
7775 }),
7776 id: OnceLock::new(),
7777});
7778pub static SEAGRASS_MID: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7779 key: Identifier::vanilla_static("seagrass_mid"),
7780 kind: ConfiguredFeatureKind::Seagrass(SeagrassConfiguration {
7781 probability: 0.6f32,
7782 }),
7783 id: OnceLock::new(),
7784});
7785pub static SEAGRASS_SHORT: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7786 key: Identifier::vanilla_static("seagrass_short"),
7787 kind: ConfiguredFeatureKind::Seagrass(SeagrassConfiguration {
7788 probability: 0.3f32,
7789 }),
7790 id: OnceLock::new(),
7791});
7792pub static SEAGRASS_SLIGHTLY_LESS_SHORT: LazyLock<ConfiguredFeature> =
7793 LazyLock::new(|| ConfiguredFeature {
7794 key: Identifier::vanilla_static("seagrass_slightly_less_short"),
7795 kind: ConfiguredFeatureKind::Seagrass(SeagrassConfiguration {
7796 probability: 0.4f32,
7797 }),
7798 id: OnceLock::new(),
7799 });
7800pub static SEAGRASS_TALL: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7801 key: Identifier::vanilla_static("seagrass_tall"),
7802 kind: ConfiguredFeatureKind::Seagrass(SeagrassConfiguration {
7803 probability: 0.8f32,
7804 }),
7805 id: OnceLock::new(),
7806});
7807pub static SMALL_BASALT_COLUMNS: LazyLock<ConfiguredFeature> =
7808 LazyLock::new(|| ConfiguredFeature {
7809 key: Identifier::vanilla_static("small_basalt_columns"),
7810 kind: ConfiguredFeatureKind::BasaltColumns(BasaltColumnsConfiguration {
7811 height: IntProvider::Uniform {
7812 min_inclusive: 1i32,
7813 max_inclusive: 4i32,
7814 },
7815 reach: IntProvider::Constant(1i32),
7816 }),
7817 id: OnceLock::new(),
7818 });
7819pub static SPORE_BLOSSOM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7820 key: Identifier::vanilla_static("spore_blossom"),
7821 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
7822 to_place: BlockStateProvider::Simple {
7823 state: BlockStateData {
7824 block: &vanilla_blocks::SPORE_BLOSSOM,
7825 properties: &[],
7826 },
7827 },
7828 schedule_tick: false,
7829 }),
7830 id: OnceLock::new(),
7831});
7832pub static SPRING_LAVA_FROZEN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7833 key: Identifier::vanilla_static("spring_lava_frozen"),
7834 kind: ConfiguredFeatureKind::SpringFeature(SpringConfiguration {
7835 state: FluidStateData {
7836 fluid: &vanilla_fluids::LAVA,
7837 properties: &[("falling", "true")],
7838 },
7839 requires_block_below: true,
7840 rock_count: 4i32,
7841 hole_count: 1i32,
7842 valid_blocks: BlockRefList(vec![
7843 &vanilla_blocks::SNOW_BLOCK,
7844 &vanilla_blocks::POWDER_SNOW,
7845 &vanilla_blocks::PACKED_ICE,
7846 ]),
7847 }),
7848 id: OnceLock::new(),
7849});
7850pub static SPRING_LAVA_NETHER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7851 key: Identifier::vanilla_static("spring_lava_nether"),
7852 kind: ConfiguredFeatureKind::SpringFeature(SpringConfiguration {
7853 state: FluidStateData {
7854 fluid: &vanilla_fluids::LAVA,
7855 properties: &[("falling", "true")],
7856 },
7857 requires_block_below: true,
7858 rock_count: 4i32,
7859 hole_count: 1i32,
7860 valid_blocks: BlockRefList(vec![
7861 &vanilla_blocks::NETHERRACK,
7862 &vanilla_blocks::SOUL_SAND,
7863 &vanilla_blocks::GRAVEL,
7864 &vanilla_blocks::MAGMA_BLOCK,
7865 &vanilla_blocks::BLACKSTONE,
7866 ]),
7867 }),
7868 id: OnceLock::new(),
7869});
7870pub static SPRING_LAVA_OVERWORLD: LazyLock<ConfiguredFeature> =
7871 LazyLock::new(|| ConfiguredFeature {
7872 key: Identifier::vanilla_static("spring_lava_overworld"),
7873 kind: ConfiguredFeatureKind::SpringFeature(SpringConfiguration {
7874 state: FluidStateData {
7875 fluid: &vanilla_fluids::LAVA,
7876 properties: &[("falling", "true")],
7877 },
7878 requires_block_below: true,
7879 rock_count: 4i32,
7880 hole_count: 1i32,
7881 valid_blocks: BlockRefList(vec![
7882 &vanilla_blocks::STONE,
7883 &vanilla_blocks::GRANITE,
7884 &vanilla_blocks::DIORITE,
7885 &vanilla_blocks::ANDESITE,
7886 &vanilla_blocks::DEEPSLATE,
7887 &vanilla_blocks::TUFF,
7888 &vanilla_blocks::CALCITE,
7889 &vanilla_blocks::DIRT,
7890 ]),
7891 }),
7892 id: OnceLock::new(),
7893 });
7894pub static SPRING_NETHER_CLOSED: LazyLock<ConfiguredFeature> =
7895 LazyLock::new(|| ConfiguredFeature {
7896 key: Identifier::vanilla_static("spring_nether_closed"),
7897 kind: ConfiguredFeatureKind::SpringFeature(SpringConfiguration {
7898 state: FluidStateData {
7899 fluid: &vanilla_fluids::LAVA,
7900 properties: &[("falling", "true")],
7901 },
7902 requires_block_below: false,
7903 rock_count: 5i32,
7904 hole_count: 0i32,
7905 valid_blocks: BlockRefList(vec![&vanilla_blocks::NETHERRACK]),
7906 }),
7907 id: OnceLock::new(),
7908 });
7909pub static SPRING_NETHER_OPEN: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7910 key: Identifier::vanilla_static("spring_nether_open"),
7911 kind: ConfiguredFeatureKind::SpringFeature(SpringConfiguration {
7912 state: FluidStateData {
7913 fluid: &vanilla_fluids::LAVA,
7914 properties: &[("falling", "true")],
7915 },
7916 requires_block_below: false,
7917 rock_count: 4i32,
7918 hole_count: 1i32,
7919 valid_blocks: BlockRefList(vec![&vanilla_blocks::NETHERRACK]),
7920 }),
7921 id: OnceLock::new(),
7922});
7923pub static SPRING_WATER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7924 key: Identifier::vanilla_static("spring_water"),
7925 kind: ConfiguredFeatureKind::SpringFeature(SpringConfiguration {
7926 state: FluidStateData {
7927 fluid: &vanilla_fluids::WATER,
7928 properties: &[("falling", "true")],
7929 },
7930 requires_block_below: true,
7931 rock_count: 4i32,
7932 hole_count: 1i32,
7933 valid_blocks: BlockRefList(vec![
7934 &vanilla_blocks::STONE,
7935 &vanilla_blocks::GRANITE,
7936 &vanilla_blocks::DIORITE,
7937 &vanilla_blocks::ANDESITE,
7938 &vanilla_blocks::DEEPSLATE,
7939 &vanilla_blocks::TUFF,
7940 &vanilla_blocks::CALCITE,
7941 &vanilla_blocks::DIRT,
7942 &vanilla_blocks::SNOW_BLOCK,
7943 &vanilla_blocks::POWDER_SNOW,
7944 &vanilla_blocks::PACKED_ICE,
7945 ]),
7946 }),
7947 id: OnceLock::new(),
7948});
7949pub static SPRUCE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
7950 key: Identifier::vanilla_static("spruce"),
7951 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
7952 trunk_provider: BlockStateProvider::Simple {
7953 state: BlockStateData {
7954 block: &vanilla_blocks::SPRUCE_LOG,
7955 properties: &[("axis", "y")],
7956 },
7957 },
7958 below_trunk_provider: BlockStateProvider::RuleBased {
7959 fallback: None,
7960 rules: vec![RuleBasedStateProviderRule {
7961 if_true: BlockPredicate::Not {
7962 predicate: Box::new(BlockPredicate::MatchingBlockTag {
7963 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
7964 offset: [0i32, 0i32, 0i32],
7965 }),
7966 },
7967 then: BlockStateProvider::Simple {
7968 state: BlockStateData {
7969 block: &vanilla_blocks::DIRT,
7970 properties: &[],
7971 },
7972 },
7973 }],
7974 },
7975 foliage_provider: BlockStateProvider::Simple {
7976 state: BlockStateData {
7977 block: &vanilla_blocks::SPRUCE_LEAVES,
7978 properties: &[
7979 ("distance", "7"),
7980 ("persistent", "false"),
7981 ("waterlogged", "false"),
7982 ],
7983 },
7984 },
7985 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
7986 base_height: 5i32,
7987 height_rand_a: 2i32,
7988 height_rand_b: 1i32,
7989 }),
7990 foliage_placer: FoliagePlacer::Spruce(SpruceFoliagePlacer {
7991 radius: IntProvider::Uniform {
7992 min_inclusive: 2i32,
7993 max_inclusive: 3i32,
7994 },
7995 offset: IntProvider::Uniform {
7996 min_inclusive: 0i32,
7997 max_inclusive: 2i32,
7998 },
7999 trunk_height: IntProvider::Uniform {
8000 min_inclusive: 1i32,
8001 max_inclusive: 2i32,
8002 },
8003 }),
8004 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
8005 limit: 2i32,
8006 lower_size: 0i32,
8007 upper_size: 2i32,
8008 min_clipped_height: None,
8009 }),
8010 decorators: vec![],
8011 root_placer: None,
8012 ignore_vines: true,
8013 }),
8014 id: OnceLock::new(),
8015});
8016pub static SUGAR_CANE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8017 key: Identifier::vanilla_static("sugar_cane"),
8018 kind: ConfiguredFeatureKind::BlockColumn(BlockColumnConfiguration {
8019 direction: Direction::Up,
8020 allowed_placement: BlockPredicate::MatchingBlockTag {
8021 tag: Identifier::vanilla_static("air"),
8022 offset: [0i32, 0i32, 0i32],
8023 },
8024 layers: vec![BlockColumnLayer {
8025 height: IntProvider::BiasedToBottom {
8026 min_inclusive: 2i32,
8027 max_inclusive: 4i32,
8028 },
8029 provider: BlockStateProvider::Simple {
8030 state: BlockStateData {
8031 block: &vanilla_blocks::SUGAR_CANE,
8032 properties: &[("age", "0")],
8033 },
8034 },
8035 }],
8036 prioritize_tip: false,
8037 }),
8038 id: OnceLock::new(),
8039});
8040pub static SUNFLOWER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8041 key: Identifier::vanilla_static("sunflower"),
8042 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
8043 to_place: BlockStateProvider::Simple {
8044 state: BlockStateData {
8045 block: &vanilla_blocks::SUNFLOWER,
8046 properties: &[("half", "lower")],
8047 },
8048 },
8049 schedule_tick: false,
8050 }),
8051 id: OnceLock::new(),
8052});
8053pub static SUPER_BIRCH_BEES: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8054 key: Identifier::vanilla_static("super_birch_bees"),
8055 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
8056 trunk_provider: BlockStateProvider::Simple {
8057 state: BlockStateData {
8058 block: &vanilla_blocks::BIRCH_LOG,
8059 properties: &[("axis", "y")],
8060 },
8061 },
8062 below_trunk_provider: BlockStateProvider::RuleBased {
8063 fallback: None,
8064 rules: vec![RuleBasedStateProviderRule {
8065 if_true: BlockPredicate::Not {
8066 predicate: Box::new(BlockPredicate::MatchingBlockTag {
8067 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
8068 offset: [0i32, 0i32, 0i32],
8069 }),
8070 },
8071 then: BlockStateProvider::Simple {
8072 state: BlockStateData {
8073 block: &vanilla_blocks::DIRT,
8074 properties: &[],
8075 },
8076 },
8077 }],
8078 },
8079 foliage_provider: BlockStateProvider::Simple {
8080 state: BlockStateData {
8081 block: &vanilla_blocks::BIRCH_LEAVES,
8082 properties: &[
8083 ("distance", "7"),
8084 ("persistent", "false"),
8085 ("waterlogged", "false"),
8086 ],
8087 },
8088 },
8089 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
8090 base_height: 5i32,
8091 height_rand_a: 2i32,
8092 height_rand_b: 6i32,
8093 }),
8094 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
8095 radius: IntProvider::Constant(2i32),
8096 offset: IntProvider::Constant(0i32),
8097 height: IntProvider::Constant(3i32),
8098 }),
8099 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
8100 limit: 1i32,
8101 lower_size: 0i32,
8102 upper_size: 1i32,
8103 min_clipped_height: None,
8104 }),
8105 decorators: vec![TreeDecorator::Beehive { probability: 1f32 }],
8106 root_placer: None,
8107 ignore_vines: true,
8108 }),
8109 id: OnceLock::new(),
8110});
8111pub static SUPER_BIRCH_BEES_0002: LazyLock<ConfiguredFeature> =
8112 LazyLock::new(|| ConfiguredFeature {
8113 key: Identifier::vanilla_static("super_birch_bees_0002"),
8114 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
8115 trunk_provider: BlockStateProvider::Simple {
8116 state: BlockStateData {
8117 block: &vanilla_blocks::BIRCH_LOG,
8118 properties: &[("axis", "y")],
8119 },
8120 },
8121 below_trunk_provider: BlockStateProvider::RuleBased {
8122 fallback: None,
8123 rules: vec![RuleBasedStateProviderRule {
8124 if_true: BlockPredicate::Not {
8125 predicate: Box::new(BlockPredicate::MatchingBlockTag {
8126 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
8127 offset: [0i32, 0i32, 0i32],
8128 }),
8129 },
8130 then: BlockStateProvider::Simple {
8131 state: BlockStateData {
8132 block: &vanilla_blocks::DIRT,
8133 properties: &[],
8134 },
8135 },
8136 }],
8137 },
8138 foliage_provider: BlockStateProvider::Simple {
8139 state: BlockStateData {
8140 block: &vanilla_blocks::BIRCH_LEAVES,
8141 properties: &[
8142 ("distance", "7"),
8143 ("persistent", "false"),
8144 ("waterlogged", "false"),
8145 ],
8146 },
8147 },
8148 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
8149 base_height: 5i32,
8150 height_rand_a: 2i32,
8151 height_rand_b: 6i32,
8152 }),
8153 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
8154 radius: IntProvider::Constant(2i32),
8155 offset: IntProvider::Constant(0i32),
8156 height: IntProvider::Constant(3i32),
8157 }),
8158 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
8159 limit: 1i32,
8160 lower_size: 0i32,
8161 upper_size: 1i32,
8162 min_clipped_height: None,
8163 }),
8164 decorators: vec![TreeDecorator::Beehive {
8165 probability: 0.002f32,
8166 }],
8167 root_placer: None,
8168 ignore_vines: true,
8169 }),
8170 id: OnceLock::new(),
8171 });
8172pub static SWAMP_OAK: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8173 key: Identifier::vanilla_static("swamp_oak"),
8174 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
8175 trunk_provider: BlockStateProvider::Simple {
8176 state: BlockStateData {
8177 block: &vanilla_blocks::OAK_LOG,
8178 properties: &[("axis", "y")],
8179 },
8180 },
8181 below_trunk_provider: BlockStateProvider::RuleBased {
8182 fallback: None,
8183 rules: vec![RuleBasedStateProviderRule {
8184 if_true: BlockPredicate::Not {
8185 predicate: Box::new(BlockPredicate::MatchingBlockTag {
8186 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
8187 offset: [0i32, 0i32, 0i32],
8188 }),
8189 },
8190 then: BlockStateProvider::Simple {
8191 state: BlockStateData {
8192 block: &vanilla_blocks::DIRT,
8193 properties: &[],
8194 },
8195 },
8196 }],
8197 },
8198 foliage_provider: BlockStateProvider::Simple {
8199 state: BlockStateData {
8200 block: &vanilla_blocks::OAK_LEAVES,
8201 properties: &[
8202 ("distance", "7"),
8203 ("persistent", "false"),
8204 ("waterlogged", "false"),
8205 ],
8206 },
8207 },
8208 trunk_placer: TrunkPlacer::Straight(TrunkPlacerBase {
8209 base_height: 5i32,
8210 height_rand_a: 3i32,
8211 height_rand_b: 0i32,
8212 }),
8213 foliage_placer: FoliagePlacer::Blob(BlobFoliagePlacer {
8214 radius: IntProvider::Constant(3i32),
8215 offset: IntProvider::Constant(0i32),
8216 height: IntProvider::Constant(3i32),
8217 }),
8218 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
8219 limit: 1i32,
8220 lower_size: 0i32,
8221 upper_size: 1i32,
8222 min_clipped_height: None,
8223 }),
8224 decorators: vec![TreeDecorator::LeaveVine {
8225 probability: 0.25f32,
8226 }],
8227 root_placer: None,
8228 ignore_vines: false,
8229 }),
8230 id: OnceLock::new(),
8231});
8232pub static TAIGA_GRASS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8233 key: Identifier::vanilla_static("taiga_grass"),
8234 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
8235 to_place: BlockStateProvider::Weighted {
8236 entries: vec![
8237 WeightedBlockState {
8238 data: BlockStateData {
8239 block: &vanilla_blocks::SHORT_GRASS,
8240 properties: &[],
8241 },
8242 weight: 1i32,
8243 },
8244 WeightedBlockState {
8245 data: BlockStateData {
8246 block: &vanilla_blocks::FERN,
8247 properties: &[],
8248 },
8249 weight: 4i32,
8250 },
8251 ],
8252 },
8253 schedule_tick: false,
8254 }),
8255 id: OnceLock::new(),
8256});
8257pub static TALL_GRASS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8258 key: Identifier::vanilla_static("tall_grass"),
8259 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
8260 to_place: BlockStateProvider::Simple {
8261 state: BlockStateData {
8262 block: &vanilla_blocks::TALL_GRASS,
8263 properties: &[("half", "lower")],
8264 },
8265 },
8266 schedule_tick: false,
8267 }),
8268 id: OnceLock::new(),
8269});
8270pub static TALL_MANGROVE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8271 key: Identifier::vanilla_static("tall_mangrove"),
8272 kind: ConfiguredFeatureKind::Tree(TreeConfiguration {
8273 trunk_provider: BlockStateProvider::Simple {
8274 state: BlockStateData {
8275 block: &vanilla_blocks::MANGROVE_LOG,
8276 properties: &[("axis", "y")],
8277 },
8278 },
8279 below_trunk_provider: BlockStateProvider::RuleBased {
8280 fallback: None,
8281 rules: vec![RuleBasedStateProviderRule {
8282 if_true: BlockPredicate::Not {
8283 predicate: Box::new(BlockPredicate::MatchingBlockTag {
8284 tag: Identifier::vanilla_static("cannot_replace_below_tree_trunk"),
8285 offset: [0i32, 0i32, 0i32],
8286 }),
8287 },
8288 then: BlockStateProvider::Simple {
8289 state: BlockStateData {
8290 block: &vanilla_blocks::DIRT,
8291 properties: &[],
8292 },
8293 },
8294 }],
8295 },
8296 foliage_provider: BlockStateProvider::Simple {
8297 state: BlockStateData {
8298 block: &vanilla_blocks::MANGROVE_LEAVES,
8299 properties: &[
8300 ("distance", "7"),
8301 ("persistent", "false"),
8302 ("waterlogged", "false"),
8303 ],
8304 },
8305 },
8306 trunk_placer: TrunkPlacer::UpwardsBranching(UpwardsBranchingTrunkPlacer {
8307 base_height: 4i32,
8308 height_rand_a: 1i32,
8309 height_rand_b: 9i32,
8310 extra_branch_steps: IntProvider::Uniform {
8311 min_inclusive: 1i32,
8312 max_inclusive: 6i32,
8313 },
8314 extra_branch_length: IntProvider::Uniform {
8315 min_inclusive: 0i32,
8316 max_inclusive: 1i32,
8317 },
8318 place_branch_per_log_probability: 0.5f32,
8319 can_grow_through: Identifier::vanilla_static("mangrove_logs_can_grow_through"),
8320 }),
8321 foliage_placer: FoliagePlacer::RandomSpread(RandomSpreadFoliagePlacer {
8322 radius: IntProvider::Constant(3i32),
8323 offset: IntProvider::Constant(0i32),
8324 foliage_height: 2i32,
8325 leaf_placement_attempts: 70i32,
8326 }),
8327 minimum_size: FeatureSize::TwoLayers(TwoLayersFeatureSize {
8328 limit: 3i32,
8329 lower_size: 0i32,
8330 upper_size: 2i32,
8331 min_clipped_height: None,
8332 }),
8333 decorators: vec![
8334 TreeDecorator::LeaveVine {
8335 probability: 0.125f32,
8336 },
8337 TreeDecorator::AttachedToLeaves(AttachedToLeavesDecorator {
8338 probability: 0.14f32,
8339 exclusion_radius_xz: 1i32,
8340 exclusion_radius_y: 0i32,
8341 required_empty_blocks: 2i32,
8342 block_provider: BlockStateProvider::RandomizedInt {
8343 property: "age".to_string(),
8344 source: Box::new(BlockStateProvider::Simple {
8345 state: BlockStateData {
8346 block: &vanilla_blocks::MANGROVE_PROPAGULE,
8347 properties: &[
8348 ("age", "0"),
8349 ("hanging", "true"),
8350 ("stage", "0"),
8351 ("waterlogged", "false"),
8352 ],
8353 },
8354 }),
8355 values: IntProvider::Uniform {
8356 min_inclusive: 0i32,
8357 max_inclusive: 4i32,
8358 },
8359 },
8360 directions: vec![Direction::Down],
8361 }),
8362 TreeDecorator::Beehive {
8363 probability: 0.01f32,
8364 },
8365 ],
8366 root_placer: Some(RootPlacer::Mangrove(MangroveRootPlacer {
8367 trunk_offset_y: IntProvider::Uniform {
8368 min_inclusive: 3i32,
8369 max_inclusive: 7i32,
8370 },
8371 root_provider: BlockStateProvider::Simple {
8372 state: BlockStateData {
8373 block: &vanilla_blocks::MANGROVE_ROOTS,
8374 properties: &[("waterlogged", "false")],
8375 },
8376 },
8377 above_root_placement: AboveRootPlacement {
8378 above_root_provider: BlockStateProvider::Simple {
8379 state: BlockStateData {
8380 block: &vanilla_blocks::MOSS_CARPET,
8381 properties: &[],
8382 },
8383 },
8384 above_root_placement_chance: 0.5f32,
8385 },
8386 mangrove_root_placement: MangroveRootPlacement {
8387 can_grow_through: Identifier::vanilla_static("mangrove_roots_can_grow_through"),
8388 muddy_roots_in: vec![
8389 Identifier::vanilla_static("mud"),
8390 Identifier::vanilla_static("muddy_mangrove_roots"),
8391 ],
8392 muddy_roots_provider: BlockStateProvider::Simple {
8393 state: BlockStateData {
8394 block: &vanilla_blocks::MUDDY_MANGROVE_ROOTS,
8395 properties: &[("axis", "y")],
8396 },
8397 },
8398 max_root_width: 8i32,
8399 max_root_length: 15i32,
8400 random_skew_chance: 0.2f32,
8401 },
8402 })),
8403 ignore_vines: true,
8404 }),
8405 id: OnceLock::new(),
8406});
8407pub static TREES_BADLANDS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8408 key: Identifier::vanilla_static("trees_badlands"),
8409 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8410 features: vec![WeightedPlacedFeature {
8411 chance: 0.0125f32,
8412 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::FALLEN_OAK_TREE),
8413 }],
8414 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::OAK_LEAF_LITTER),
8415 }),
8416 id: OnceLock::new(),
8417});
8418pub static TREES_BIRCH: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8419 key: Identifier::vanilla_static("trees_birch"),
8420 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8421 features: vec![WeightedPlacedFeature {
8422 chance: 0.0125f32,
8423 feature: PlacedFeatureRef::Reference(
8424 &crate::vanilla_placed_features::FALLEN_BIRCH_TREE,
8425 ),
8426 }],
8427 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::BIRCH_BEES_0002),
8428 }),
8429 id: OnceLock::new(),
8430});
8431pub static TREES_BIRCH_AND_OAK_LEAF_LITTER: LazyLock<ConfiguredFeature> =
8432 LazyLock::new(|| ConfiguredFeature {
8433 key: Identifier::vanilla_static("trees_birch_and_oak_leaf_litter"),
8434 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8435 features: vec![
8436 WeightedPlacedFeature {
8437 chance: 0.0025f32,
8438 feature: PlacedFeatureRef::Reference(
8439 &crate::vanilla_placed_features::FALLEN_BIRCH_TREE,
8440 ),
8441 },
8442 WeightedPlacedFeature {
8443 chance: 0.2f32,
8444 feature: PlacedFeatureRef::Reference(
8445 &crate::vanilla_placed_features::BIRCH_BEES_0002_LEAF_LITTER,
8446 ),
8447 },
8448 WeightedPlacedFeature {
8449 chance: 0.1f32,
8450 feature: PlacedFeatureRef::Reference(
8451 &crate::vanilla_placed_features::FANCY_OAK_BEES_0002_LEAF_LITTER,
8452 ),
8453 },
8454 WeightedPlacedFeature {
8455 chance: 0.0125f32,
8456 feature: PlacedFeatureRef::Reference(
8457 &crate::vanilla_placed_features::FALLEN_OAK_TREE,
8458 ),
8459 },
8460 ],
8461 default: PlacedFeatureRef::Reference(
8462 &crate::vanilla_placed_features::OAK_BEES_0002_LEAF_LITTER,
8463 ),
8464 }),
8465 id: OnceLock::new(),
8466 });
8467pub static TREES_FLOWER_FOREST: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8468 key: Identifier::vanilla_static("trees_flower_forest"),
8469 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8470 features: vec![
8471 WeightedPlacedFeature {
8472 chance: 0.0025f32,
8473 feature: PlacedFeatureRef::Reference(
8474 &crate::vanilla_placed_features::FALLEN_BIRCH_TREE,
8475 ),
8476 },
8477 WeightedPlacedFeature {
8478 chance: 0.2f32,
8479 feature: PlacedFeatureRef::Reference(
8480 &crate::vanilla_placed_features::BIRCH_BEES_002,
8481 ),
8482 },
8483 WeightedPlacedFeature {
8484 chance: 0.1f32,
8485 feature: PlacedFeatureRef::Reference(
8486 &crate::vanilla_placed_features::FANCY_OAK_BEES_002,
8487 ),
8488 },
8489 ],
8490 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::OAK_BEES_002),
8491 }),
8492 id: OnceLock::new(),
8493});
8494pub static TREES_GROVE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8495 key: Identifier::vanilla_static("trees_grove"),
8496 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8497 features: vec![WeightedPlacedFeature {
8498 chance: 0.33333334f32,
8499 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::PINE_ON_SNOW),
8500 }],
8501 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::SPRUCE_ON_SNOW),
8502 }),
8503 id: OnceLock::new(),
8504});
8505pub static TREES_JUNGLE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8506 key: Identifier::vanilla_static("trees_jungle"),
8507 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8508 features: vec![
8509 WeightedPlacedFeature {
8510 chance: 0.1f32,
8511 feature: PlacedFeatureRef::Reference(
8512 &crate::vanilla_placed_features::FANCY_OAK_CHECKED,
8513 ),
8514 },
8515 WeightedPlacedFeature {
8516 chance: 0.5f32,
8517 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::JUNGLE_BUSH),
8518 },
8519 WeightedPlacedFeature {
8520 chance: 0.33333334f32,
8521 feature: PlacedFeatureRef::Reference(
8522 &crate::vanilla_placed_features::MEGA_JUNGLE_TREE_CHECKED,
8523 ),
8524 },
8525 WeightedPlacedFeature {
8526 chance: 0.0125f32,
8527 feature: PlacedFeatureRef::Reference(
8528 &crate::vanilla_placed_features::FALLEN_JUNGLE_TREE,
8529 ),
8530 },
8531 ],
8532 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::JUNGLE_TREE),
8533 }),
8534 id: OnceLock::new(),
8535});
8536pub static TREES_OLD_GROWTH_PINE_TAIGA: LazyLock<ConfiguredFeature> =
8537 LazyLock::new(|| ConfiguredFeature {
8538 key: Identifier::vanilla_static("trees_old_growth_pine_taiga"),
8539 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8540 features: vec![
8541 WeightedPlacedFeature {
8542 chance: 0.025641026f32,
8543 feature: PlacedFeatureRef::Reference(
8544 &crate::vanilla_placed_features::MEGA_SPRUCE_CHECKED,
8545 ),
8546 },
8547 WeightedPlacedFeature {
8548 chance: 0.30769232f32,
8549 feature: PlacedFeatureRef::Reference(
8550 &crate::vanilla_placed_features::MEGA_PINE_CHECKED,
8551 ),
8552 },
8553 WeightedPlacedFeature {
8554 chance: 0.33333334f32,
8555 feature: PlacedFeatureRef::Reference(
8556 &crate::vanilla_placed_features::PINE_CHECKED,
8557 ),
8558 },
8559 WeightedPlacedFeature {
8560 chance: 0.0125f32,
8561 feature: PlacedFeatureRef::Reference(
8562 &crate::vanilla_placed_features::FALLEN_SPRUCE_TREE,
8563 ),
8564 },
8565 ],
8566 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::SPRUCE_CHECKED),
8567 }),
8568 id: OnceLock::new(),
8569 });
8570pub static TREES_OLD_GROWTH_SPRUCE_TAIGA: LazyLock<ConfiguredFeature> =
8571 LazyLock::new(|| ConfiguredFeature {
8572 key: Identifier::vanilla_static("trees_old_growth_spruce_taiga"),
8573 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8574 features: vec![
8575 WeightedPlacedFeature {
8576 chance: 0.33333334f32,
8577 feature: PlacedFeatureRef::Reference(
8578 &crate::vanilla_placed_features::MEGA_SPRUCE_CHECKED,
8579 ),
8580 },
8581 WeightedPlacedFeature {
8582 chance: 0.33333334f32,
8583 feature: PlacedFeatureRef::Reference(
8584 &crate::vanilla_placed_features::PINE_CHECKED,
8585 ),
8586 },
8587 WeightedPlacedFeature {
8588 chance: 0.0125f32,
8589 feature: PlacedFeatureRef::Reference(
8590 &crate::vanilla_placed_features::FALLEN_SPRUCE_TREE,
8591 ),
8592 },
8593 ],
8594 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::SPRUCE_CHECKED),
8595 }),
8596 id: OnceLock::new(),
8597 });
8598pub static TREES_PLAINS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8599 key: Identifier::vanilla_static("trees_plains"),
8600 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8601 features: vec![
8602 WeightedPlacedFeature {
8603 chance: 0.33333334f32,
8604 feature: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
8605 feature: ConfiguredFeatureRef::Reference(
8606 &crate::vanilla_configured_features::FANCY_OAK_BEES_005,
8607 ),
8608 placement: vec![],
8609 })),
8610 },
8611 WeightedPlacedFeature {
8612 chance: 0.0125f32,
8613 feature: PlacedFeatureRef::Reference(
8614 &crate::vanilla_placed_features::FALLEN_OAK_TREE,
8615 ),
8616 },
8617 ],
8618 default: PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
8619 feature: ConfiguredFeatureRef::Reference(
8620 &crate::vanilla_configured_features::OAK_BEES_005,
8621 ),
8622 placement: vec![],
8623 })),
8624 }),
8625 id: OnceLock::new(),
8626});
8627pub static TREES_SAVANNA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8628 key: Identifier::vanilla_static("trees_savanna"),
8629 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8630 features: vec![
8631 WeightedPlacedFeature {
8632 chance: 0.8f32,
8633 feature: PlacedFeatureRef::Reference(
8634 &crate::vanilla_placed_features::ACACIA_CHECKED,
8635 ),
8636 },
8637 WeightedPlacedFeature {
8638 chance: 0.0125f32,
8639 feature: PlacedFeatureRef::Reference(
8640 &crate::vanilla_placed_features::FALLEN_OAK_TREE,
8641 ),
8642 },
8643 ],
8644 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::OAK_CHECKED),
8645 }),
8646 id: OnceLock::new(),
8647});
8648pub static TREES_SNOWY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8649 key: Identifier::vanilla_static("trees_snowy"),
8650 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8651 features: vec![WeightedPlacedFeature {
8652 chance: 0.0125f32,
8653 feature: PlacedFeatureRef::Reference(
8654 &crate::vanilla_placed_features::FALLEN_SPRUCE_TREE,
8655 ),
8656 }],
8657 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::SPRUCE_CHECKED),
8658 }),
8659 id: OnceLock::new(),
8660});
8661pub static TREES_SPARSE_JUNGLE: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8662 key: Identifier::vanilla_static("trees_sparse_jungle"),
8663 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8664 features: vec![
8665 WeightedPlacedFeature {
8666 chance: 0.1f32,
8667 feature: PlacedFeatureRef::Reference(
8668 &crate::vanilla_placed_features::FANCY_OAK_CHECKED,
8669 ),
8670 },
8671 WeightedPlacedFeature {
8672 chance: 0.5f32,
8673 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::JUNGLE_BUSH),
8674 },
8675 WeightedPlacedFeature {
8676 chance: 0.0125f32,
8677 feature: PlacedFeatureRef::Reference(
8678 &crate::vanilla_placed_features::FALLEN_JUNGLE_TREE,
8679 ),
8680 },
8681 ],
8682 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::JUNGLE_TREE),
8683 }),
8684 id: OnceLock::new(),
8685});
8686pub static TREES_TAIGA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8687 key: Identifier::vanilla_static("trees_taiga"),
8688 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8689 features: vec![
8690 WeightedPlacedFeature {
8691 chance: 0.33333334f32,
8692 feature: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::PINE_CHECKED),
8693 },
8694 WeightedPlacedFeature {
8695 chance: 0.0125f32,
8696 feature: PlacedFeatureRef::Reference(
8697 &crate::vanilla_placed_features::FALLEN_SPRUCE_TREE,
8698 ),
8699 },
8700 ],
8701 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::SPRUCE_CHECKED),
8702 }),
8703 id: OnceLock::new(),
8704});
8705pub static TREES_WATER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8706 key: Identifier::vanilla_static("trees_water"),
8707 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8708 features: vec![WeightedPlacedFeature {
8709 chance: 0.1f32,
8710 feature: PlacedFeatureRef::Reference(
8711 &crate::vanilla_placed_features::FANCY_OAK_CHECKED,
8712 ),
8713 }],
8714 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::OAK_CHECKED),
8715 }),
8716 id: OnceLock::new(),
8717});
8718pub static TREES_WINDSWEPT_HILLS: LazyLock<ConfiguredFeature> =
8719 LazyLock::new(|| ConfiguredFeature {
8720 key: Identifier::vanilla_static("trees_windswept_hills"),
8721 kind: ConfiguredFeatureKind::RandomSelector(RandomSelectorConfiguration {
8722 features: vec![
8723 WeightedPlacedFeature {
8724 chance: 0.008325f32,
8725 feature: PlacedFeatureRef::Reference(
8726 &crate::vanilla_placed_features::FALLEN_SPRUCE_TREE,
8727 ),
8728 },
8729 WeightedPlacedFeature {
8730 chance: 0.666f32,
8731 feature: PlacedFeatureRef::Reference(
8732 &crate::vanilla_placed_features::SPRUCE_CHECKED,
8733 ),
8734 },
8735 WeightedPlacedFeature {
8736 chance: 0.1f32,
8737 feature: PlacedFeatureRef::Reference(
8738 &crate::vanilla_placed_features::FANCY_OAK_CHECKED,
8739 ),
8740 },
8741 WeightedPlacedFeature {
8742 chance: 0.0125f32,
8743 feature: PlacedFeatureRef::Reference(
8744 &crate::vanilla_placed_features::FALLEN_OAK_TREE,
8745 ),
8746 },
8747 ],
8748 default: PlacedFeatureRef::Reference(&crate::vanilla_placed_features::OAK_CHECKED),
8749 }),
8750 id: OnceLock::new(),
8751 });
8752pub static TWISTING_VINES: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8753 key: Identifier::vanilla_static("twisting_vines"),
8754 kind: ConfiguredFeatureKind::TwistingVines(TwistingVinesConfiguration {
8755 spread_width: 8i32,
8756 spread_height: 4i32,
8757 max_height: 8i32,
8758 }),
8759 id: OnceLock::new(),
8760});
8761pub static TWISTING_VINES_BONEMEAL: LazyLock<ConfiguredFeature> =
8762 LazyLock::new(|| ConfiguredFeature {
8763 key: Identifier::vanilla_static("twisting_vines_bonemeal"),
8764 kind: ConfiguredFeatureKind::TwistingVines(TwistingVinesConfiguration {
8765 spread_width: 3i32,
8766 spread_height: 1i32,
8767 max_height: 2i32,
8768 }),
8769 id: OnceLock::new(),
8770 });
8771pub static UNDERWATER_MAGMA: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8772 key: Identifier::vanilla_static("underwater_magma"),
8773 kind: ConfiguredFeatureKind::UnderwaterMagma(UnderwaterMagmaConfiguration {
8774 floor_search_range: 5i32,
8775 placement_radius_around_floor: 1i32,
8776 placement_probability_per_valid_position: 0.5f32,
8777 }),
8778 id: OnceLock::new(),
8779});
8780pub static VINES: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8781 key: Identifier::vanilla_static("vines"),
8782 kind: ConfiguredFeatureKind::Vines,
8783 id: OnceLock::new(),
8784});
8785pub static VOID_START_PLATFORM: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8786 key: Identifier::vanilla_static("void_start_platform"),
8787 kind: ConfiguredFeatureKind::VoidStartPlatform,
8788 id: OnceLock::new(),
8789});
8790pub static WARM_OCEAN_VEGETATION: LazyLock<ConfiguredFeature> =
8791 LazyLock::new(|| ConfiguredFeature {
8792 key: Identifier::vanilla_static("warm_ocean_vegetation"),
8793 kind: ConfiguredFeatureKind::SimpleRandomSelector(SimpleRandomSelectorConfiguration {
8794 features: vec![
8795 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
8796 feature: ConfiguredFeatureRef::Inline(Box::new(
8797 ConfiguredFeatureKind::CoralTree,
8798 )),
8799 placement: vec![],
8800 })),
8801 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
8802 feature: ConfiguredFeatureRef::Inline(Box::new(
8803 ConfiguredFeatureKind::CoralClaw,
8804 )),
8805 placement: vec![],
8806 })),
8807 PlacedFeatureRef::Inline(Box::new(PlacedFeatureData {
8808 feature: ConfiguredFeatureRef::Inline(Box::new(
8809 ConfiguredFeatureKind::CoralMushroom,
8810 )),
8811 placement: vec![],
8812 })),
8813 ],
8814 }),
8815 id: OnceLock::new(),
8816 });
8817pub static WARPED_FOREST_VEGETATION: LazyLock<ConfiguredFeature> =
8818 LazyLock::new(|| ConfiguredFeature {
8819 key: Identifier::vanilla_static("warped_forest_vegetation"),
8820 kind: ConfiguredFeatureKind::NetherForestVegetation(NetherForestVegetationConfiguration {
8821 state_provider: BlockStateProvider::Weighted {
8822 entries: vec![
8823 WeightedBlockState {
8824 data: BlockStateData {
8825 block: &vanilla_blocks::WARPED_ROOTS,
8826 properties: &[],
8827 },
8828 weight: 85i32,
8829 },
8830 WeightedBlockState {
8831 data: BlockStateData {
8832 block: &vanilla_blocks::CRIMSON_ROOTS,
8833 properties: &[],
8834 },
8835 weight: 1i32,
8836 },
8837 WeightedBlockState {
8838 data: BlockStateData {
8839 block: &vanilla_blocks::WARPED_FUNGUS,
8840 properties: &[],
8841 },
8842 weight: 13i32,
8843 },
8844 WeightedBlockState {
8845 data: BlockStateData {
8846 block: &vanilla_blocks::CRIMSON_FUNGUS,
8847 properties: &[],
8848 },
8849 weight: 1i32,
8850 },
8851 ],
8852 },
8853 spread_width: 8i32,
8854 spread_height: 4i32,
8855 }),
8856 id: OnceLock::new(),
8857 });
8858pub static WARPED_FOREST_VEGETATION_BONEMEAL: LazyLock<ConfiguredFeature> =
8859 LazyLock::new(|| ConfiguredFeature {
8860 key: Identifier::vanilla_static("warped_forest_vegetation_bonemeal"),
8861 kind: ConfiguredFeatureKind::NetherForestVegetation(NetherForestVegetationConfiguration {
8862 state_provider: BlockStateProvider::Weighted {
8863 entries: vec![
8864 WeightedBlockState {
8865 data: BlockStateData {
8866 block: &vanilla_blocks::WARPED_ROOTS,
8867 properties: &[],
8868 },
8869 weight: 85i32,
8870 },
8871 WeightedBlockState {
8872 data: BlockStateData {
8873 block: &vanilla_blocks::CRIMSON_ROOTS,
8874 properties: &[],
8875 },
8876 weight: 1i32,
8877 },
8878 WeightedBlockState {
8879 data: BlockStateData {
8880 block: &vanilla_blocks::WARPED_FUNGUS,
8881 properties: &[],
8882 },
8883 weight: 13i32,
8884 },
8885 WeightedBlockState {
8886 data: BlockStateData {
8887 block: &vanilla_blocks::CRIMSON_FUNGUS,
8888 properties: &[],
8889 },
8890 weight: 1i32,
8891 },
8892 ],
8893 },
8894 spread_width: 3i32,
8895 spread_height: 1i32,
8896 }),
8897 id: OnceLock::new(),
8898 });
8899pub static WARPED_FUNGUS: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
8900 key: Identifier::vanilla_static("warped_fungus"),
8901 kind: ConfiguredFeatureKind::HugeFungus(HugeFungusConfiguration {
8902 valid_base_block: BlockStateData {
8903 block: &vanilla_blocks::WARPED_NYLIUM,
8904 properties: &[],
8905 },
8906 stem_state: BlockStateData {
8907 block: &vanilla_blocks::WARPED_STEM,
8908 properties: &[("axis", "y")],
8909 },
8910 hat_state: BlockStateData {
8911 block: &vanilla_blocks::WARPED_WART_BLOCK,
8912 properties: &[],
8913 },
8914 decor_state: BlockStateData {
8915 block: &vanilla_blocks::SHROOMLIGHT,
8916 properties: &[],
8917 },
8918 replaceable_blocks: BlockPredicate::MatchingBlocks {
8919 blocks: BlockRefList(vec![
8920 &vanilla_blocks::OAK_SAPLING,
8921 &vanilla_blocks::SPRUCE_SAPLING,
8922 &vanilla_blocks::BIRCH_SAPLING,
8923 &vanilla_blocks::JUNGLE_SAPLING,
8924 &vanilla_blocks::ACACIA_SAPLING,
8925 &vanilla_blocks::CHERRY_SAPLING,
8926 &vanilla_blocks::DARK_OAK_SAPLING,
8927 &vanilla_blocks::PALE_OAK_SAPLING,
8928 &vanilla_blocks::MANGROVE_PROPAGULE,
8929 &vanilla_blocks::DANDELION,
8930 &vanilla_blocks::TORCHFLOWER,
8931 &vanilla_blocks::POPPY,
8932 &vanilla_blocks::BLUE_ORCHID,
8933 &vanilla_blocks::ALLIUM,
8934 &vanilla_blocks::AZURE_BLUET,
8935 &vanilla_blocks::RED_TULIP,
8936 &vanilla_blocks::ORANGE_TULIP,
8937 &vanilla_blocks::WHITE_TULIP,
8938 &vanilla_blocks::PINK_TULIP,
8939 &vanilla_blocks::OXEYE_DAISY,
8940 &vanilla_blocks::CORNFLOWER,
8941 &vanilla_blocks::WITHER_ROSE,
8942 &vanilla_blocks::LILY_OF_THE_VALLEY,
8943 &vanilla_blocks::BROWN_MUSHROOM,
8944 &vanilla_blocks::RED_MUSHROOM,
8945 &vanilla_blocks::WHEAT,
8946 &vanilla_blocks::SUGAR_CANE,
8947 &vanilla_blocks::ATTACHED_PUMPKIN_STEM,
8948 &vanilla_blocks::ATTACHED_MELON_STEM,
8949 &vanilla_blocks::PUMPKIN_STEM,
8950 &vanilla_blocks::MELON_STEM,
8951 &vanilla_blocks::LILY_PAD,
8952 &vanilla_blocks::NETHER_WART,
8953 &vanilla_blocks::COCOA,
8954 &vanilla_blocks::CARROTS,
8955 &vanilla_blocks::POTATOES,
8956 &vanilla_blocks::CHORUS_PLANT,
8957 &vanilla_blocks::CHORUS_FLOWER,
8958 &vanilla_blocks::TORCHFLOWER_CROP,
8959 &vanilla_blocks::PITCHER_CROP,
8960 &vanilla_blocks::BEETROOTS,
8961 &vanilla_blocks::SWEET_BERRY_BUSH,
8962 &vanilla_blocks::WARPED_FUNGUS,
8963 &vanilla_blocks::CRIMSON_FUNGUS,
8964 &vanilla_blocks::WEEPING_VINES,
8965 &vanilla_blocks::WEEPING_VINES_PLANT,
8966 &vanilla_blocks::TWISTING_VINES,
8967 &vanilla_blocks::TWISTING_VINES_PLANT,
8968 &vanilla_blocks::CAVE_VINES,
8969 &vanilla_blocks::CAVE_VINES_PLANT,
8970 &vanilla_blocks::SPORE_BLOSSOM,
8971 &vanilla_blocks::AZALEA,
8972 &vanilla_blocks::FLOWERING_AZALEA,
8973 &vanilla_blocks::MOSS_CARPET,
8974 &vanilla_blocks::PINK_PETALS,
8975 &vanilla_blocks::WILDFLOWERS,
8976 &vanilla_blocks::BIG_DRIPLEAF,
8977 &vanilla_blocks::BIG_DRIPLEAF_STEM,
8978 &vanilla_blocks::SMALL_DRIPLEAF,
8979 ]),
8980 offset: [0i32, 0i32, 0i32],
8981 },
8982 planted: false,
8983 }),
8984 id: OnceLock::new(),
8985});
8986pub static WARPED_FUNGUS_PLANTED: LazyLock<ConfiguredFeature> =
8987 LazyLock::new(|| ConfiguredFeature {
8988 key: Identifier::vanilla_static("warped_fungus_planted"),
8989 kind: ConfiguredFeatureKind::HugeFungus(HugeFungusConfiguration {
8990 valid_base_block: BlockStateData {
8991 block: &vanilla_blocks::WARPED_NYLIUM,
8992 properties: &[],
8993 },
8994 stem_state: BlockStateData {
8995 block: &vanilla_blocks::WARPED_STEM,
8996 properties: &[("axis", "y")],
8997 },
8998 hat_state: BlockStateData {
8999 block: &vanilla_blocks::WARPED_WART_BLOCK,
9000 properties: &[],
9001 },
9002 decor_state: BlockStateData {
9003 block: &vanilla_blocks::SHROOMLIGHT,
9004 properties: &[],
9005 },
9006 replaceable_blocks: BlockPredicate::MatchingBlocks {
9007 blocks: BlockRefList(vec![
9008 &vanilla_blocks::OAK_SAPLING,
9009 &vanilla_blocks::SPRUCE_SAPLING,
9010 &vanilla_blocks::BIRCH_SAPLING,
9011 &vanilla_blocks::JUNGLE_SAPLING,
9012 &vanilla_blocks::ACACIA_SAPLING,
9013 &vanilla_blocks::CHERRY_SAPLING,
9014 &vanilla_blocks::DARK_OAK_SAPLING,
9015 &vanilla_blocks::PALE_OAK_SAPLING,
9016 &vanilla_blocks::MANGROVE_PROPAGULE,
9017 &vanilla_blocks::DANDELION,
9018 &vanilla_blocks::TORCHFLOWER,
9019 &vanilla_blocks::POPPY,
9020 &vanilla_blocks::BLUE_ORCHID,
9021 &vanilla_blocks::ALLIUM,
9022 &vanilla_blocks::AZURE_BLUET,
9023 &vanilla_blocks::RED_TULIP,
9024 &vanilla_blocks::ORANGE_TULIP,
9025 &vanilla_blocks::WHITE_TULIP,
9026 &vanilla_blocks::PINK_TULIP,
9027 &vanilla_blocks::OXEYE_DAISY,
9028 &vanilla_blocks::CORNFLOWER,
9029 &vanilla_blocks::WITHER_ROSE,
9030 &vanilla_blocks::LILY_OF_THE_VALLEY,
9031 &vanilla_blocks::BROWN_MUSHROOM,
9032 &vanilla_blocks::RED_MUSHROOM,
9033 &vanilla_blocks::WHEAT,
9034 &vanilla_blocks::SUGAR_CANE,
9035 &vanilla_blocks::ATTACHED_PUMPKIN_STEM,
9036 &vanilla_blocks::ATTACHED_MELON_STEM,
9037 &vanilla_blocks::PUMPKIN_STEM,
9038 &vanilla_blocks::MELON_STEM,
9039 &vanilla_blocks::LILY_PAD,
9040 &vanilla_blocks::NETHER_WART,
9041 &vanilla_blocks::COCOA,
9042 &vanilla_blocks::CARROTS,
9043 &vanilla_blocks::POTATOES,
9044 &vanilla_blocks::CHORUS_PLANT,
9045 &vanilla_blocks::CHORUS_FLOWER,
9046 &vanilla_blocks::TORCHFLOWER_CROP,
9047 &vanilla_blocks::PITCHER_CROP,
9048 &vanilla_blocks::BEETROOTS,
9049 &vanilla_blocks::SWEET_BERRY_BUSH,
9050 &vanilla_blocks::WARPED_FUNGUS,
9051 &vanilla_blocks::CRIMSON_FUNGUS,
9052 &vanilla_blocks::WEEPING_VINES,
9053 &vanilla_blocks::WEEPING_VINES_PLANT,
9054 &vanilla_blocks::TWISTING_VINES,
9055 &vanilla_blocks::TWISTING_VINES_PLANT,
9056 &vanilla_blocks::CAVE_VINES,
9057 &vanilla_blocks::CAVE_VINES_PLANT,
9058 &vanilla_blocks::SPORE_BLOSSOM,
9059 &vanilla_blocks::AZALEA,
9060 &vanilla_blocks::FLOWERING_AZALEA,
9061 &vanilla_blocks::MOSS_CARPET,
9062 &vanilla_blocks::PINK_PETALS,
9063 &vanilla_blocks::WILDFLOWERS,
9064 &vanilla_blocks::BIG_DRIPLEAF,
9065 &vanilla_blocks::BIG_DRIPLEAF_STEM,
9066 &vanilla_blocks::SMALL_DRIPLEAF,
9067 ]),
9068 offset: [0i32, 0i32, 0i32],
9069 },
9070 planted: true,
9071 }),
9072 id: OnceLock::new(),
9073 });
9074pub static WATERLILY: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
9075 key: Identifier::vanilla_static("waterlily"),
9076 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
9077 to_place: BlockStateProvider::Simple {
9078 state: BlockStateData {
9079 block: &vanilla_blocks::LILY_PAD,
9080 properties: &[],
9081 },
9082 },
9083 schedule_tick: false,
9084 }),
9085 id: OnceLock::new(),
9086});
9087pub static WEEPING_VINES: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
9088 key: Identifier::vanilla_static("weeping_vines"),
9089 kind: ConfiguredFeatureKind::WeepingVines,
9090 id: OnceLock::new(),
9091});
9092pub static WILDFLOWER: LazyLock<ConfiguredFeature> = LazyLock::new(|| ConfiguredFeature {
9093 key: Identifier::vanilla_static("wildflower"),
9094 kind: ConfiguredFeatureKind::SimpleBlock(SimpleBlockConfiguration {
9095 to_place: BlockStateProvider::Weighted {
9096 entries: vec![
9097 WeightedBlockState {
9098 data: BlockStateData {
9099 block: &vanilla_blocks::WILDFLOWERS,
9100 properties: &[("facing", "north"), ("flower_amount", "1")],
9101 },
9102 weight: 1i32,
9103 },
9104 WeightedBlockState {
9105 data: BlockStateData {
9106 block: &vanilla_blocks::WILDFLOWERS,
9107 properties: &[("facing", "east"), ("flower_amount", "1")],
9108 },
9109 weight: 1i32,
9110 },
9111 WeightedBlockState {
9112 data: BlockStateData {
9113 block: &vanilla_blocks::WILDFLOWERS,
9114 properties: &[("facing", "south"), ("flower_amount", "1")],
9115 },
9116 weight: 1i32,
9117 },
9118 WeightedBlockState {
9119 data: BlockStateData {
9120 block: &vanilla_blocks::WILDFLOWERS,
9121 properties: &[("facing", "west"), ("flower_amount", "1")],
9122 },
9123 weight: 1i32,
9124 },
9125 WeightedBlockState {
9126 data: BlockStateData {
9127 block: &vanilla_blocks::WILDFLOWERS,
9128 properties: &[("facing", "north"), ("flower_amount", "2")],
9129 },
9130 weight: 1i32,
9131 },
9132 WeightedBlockState {
9133 data: BlockStateData {
9134 block: &vanilla_blocks::WILDFLOWERS,
9135 properties: &[("facing", "east"), ("flower_amount", "2")],
9136 },
9137 weight: 1i32,
9138 },
9139 WeightedBlockState {
9140 data: BlockStateData {
9141 block: &vanilla_blocks::WILDFLOWERS,
9142 properties: &[("facing", "south"), ("flower_amount", "2")],
9143 },
9144 weight: 1i32,
9145 },
9146 WeightedBlockState {
9147 data: BlockStateData {
9148 block: &vanilla_blocks::WILDFLOWERS,
9149 properties: &[("facing", "west"), ("flower_amount", "2")],
9150 },
9151 weight: 1i32,
9152 },
9153 WeightedBlockState {
9154 data: BlockStateData {
9155 block: &vanilla_blocks::WILDFLOWERS,
9156 properties: &[("facing", "north"), ("flower_amount", "3")],
9157 },
9158 weight: 1i32,
9159 },
9160 WeightedBlockState {
9161 data: BlockStateData {
9162 block: &vanilla_blocks::WILDFLOWERS,
9163 properties: &[("facing", "east"), ("flower_amount", "3")],
9164 },
9165 weight: 1i32,
9166 },
9167 WeightedBlockState {
9168 data: BlockStateData {
9169 block: &vanilla_blocks::WILDFLOWERS,
9170 properties: &[("facing", "south"), ("flower_amount", "3")],
9171 },
9172 weight: 1i32,
9173 },
9174 WeightedBlockState {
9175 data: BlockStateData {
9176 block: &vanilla_blocks::WILDFLOWERS,
9177 properties: &[("facing", "west"), ("flower_amount", "3")],
9178 },
9179 weight: 1i32,
9180 },
9181 WeightedBlockState {
9182 data: BlockStateData {
9183 block: &vanilla_blocks::WILDFLOWERS,
9184 properties: &[("facing", "north"), ("flower_amount", "4")],
9185 },
9186 weight: 1i32,
9187 },
9188 WeightedBlockState {
9189 data: BlockStateData {
9190 block: &vanilla_blocks::WILDFLOWERS,
9191 properties: &[("facing", "east"), ("flower_amount", "4")],
9192 },
9193 weight: 1i32,
9194 },
9195 WeightedBlockState {
9196 data: BlockStateData {
9197 block: &vanilla_blocks::WILDFLOWERS,
9198 properties: &[("facing", "south"), ("flower_amount", "4")],
9199 },
9200 weight: 1i32,
9201 },
9202 WeightedBlockState {
9203 data: BlockStateData {
9204 block: &vanilla_blocks::WILDFLOWERS,
9205 properties: &[("facing", "west"), ("flower_amount", "4")],
9206 },
9207 weight: 1i32,
9208 },
9209 ],
9210 },
9211 schedule_tick: false,
9212 }),
9213 id: OnceLock::new(),
9214});
9215pub fn register_configured_features(registry: &mut ConfiguredFeatureRegistry) {
9216 registry.register(&ACACIA);
9217 registry.register(&AMETHYST_GEODE);
9218 registry.register(&AZALEA_TREE);
9219 registry.register(&BAMBOO_NO_PODZOL);
9220 registry.register(&BAMBOO_SOME_PODZOL);
9221 registry.register(&BAMBOO_VEGETATION);
9222 registry.register(&BASALT_BLOBS);
9223 registry.register(&BASALT_PILLAR);
9224 registry.register(&BERRY_BUSH);
9225 registry.register(&BIRCH);
9226 registry.register(&BIRCH_BEES_0002);
9227 registry.register(&BIRCH_BEES_0002_LEAF_LITTER);
9228 registry.register(&BIRCH_BEES_002);
9229 registry.register(&BIRCH_BEES_005);
9230 registry.register(&BIRCH_LEAF_LITTER);
9231 registry.register(&BIRCH_TALL);
9232 registry.register(&BLACKSTONE_BLOBS);
9233 registry.register(&BLUE_ICE);
9234 registry.register(&BONUS_CHEST);
9235 registry.register(&BROWN_MUSHROOM);
9236 registry.register(&BUSH);
9237 registry.register(&CACTUS);
9238 registry.register(&CAVE_VINE);
9239 registry.register(&CAVE_VINE_IN_MOSS);
9240 registry.register(&CHERRY);
9241 registry.register(&CHERRY_BEES_005);
9242 registry.register(&CHORUS_PLANT);
9243 registry.register(&CLAY_POOL_WITH_DRIPLEAVES);
9244 registry.register(&CLAY_WITH_DRIPLEAVES);
9245 registry.register(&CRIMSON_FOREST_VEGETATION);
9246 registry.register(&CRIMSON_FOREST_VEGETATION_BONEMEAL);
9247 registry.register(&CRIMSON_FUNGUS);
9248 registry.register(&CRIMSON_FUNGUS_PLANTED);
9249 registry.register(&CRIMSON_ROOTS);
9250 registry.register(&DARK_FOREST_VEGETATION);
9251 registry.register(&DARK_OAK);
9252 registry.register(&DARK_OAK_LEAF_LITTER);
9253 registry.register(&DEAD_BUSH);
9254 registry.register(&DELTA);
9255 registry.register(&DESERT_WELL);
9256 registry.register(&DISK_CLAY);
9257 registry.register(&DISK_GRASS);
9258 registry.register(&DISK_GRAVEL);
9259 registry.register(&DISK_SAND);
9260 registry.register(&DRIPLEAF);
9261 registry.register(&DRIPSTONE_CLUSTER);
9262 registry.register(&DRY_GRASS);
9263 registry.register(&END_GATEWAY_DELAYED);
9264 registry.register(&END_GATEWAY_RETURN);
9265 registry.register(&END_ISLAND);
9266 registry.register(&END_PLATFORM);
9267 registry.register(&END_SPIKE);
9268 registry.register(&FALLEN_BIRCH_TREE);
9269 registry.register(&FALLEN_JUNGLE_TREE);
9270 registry.register(&FALLEN_OAK_TREE);
9271 registry.register(&FALLEN_SPRUCE_TREE);
9272 registry.register(&FALLEN_SUPER_BIRCH_TREE);
9273 registry.register(&FANCY_OAK);
9274 registry.register(&FANCY_OAK_BEES);
9275 registry.register(&FANCY_OAK_BEES_0002_LEAF_LITTER);
9276 registry.register(&FANCY_OAK_BEES_002);
9277 registry.register(&FANCY_OAK_BEES_005);
9278 registry.register(&FANCY_OAK_LEAF_LITTER);
9279 registry.register(&FIREFLY_BUSH);
9280 registry.register(&FLOWER_CHERRY);
9281 registry.register(&FLOWER_DEFAULT);
9282 registry.register(&FLOWER_FLOWER_FOREST);
9283 registry.register(&FLOWER_MEADOW);
9284 registry.register(&FLOWER_PALE_GARDEN);
9285 registry.register(&FLOWER_PLAIN);
9286 registry.register(&FLOWER_SWAMP);
9287 registry.register(&FOREST_FLOWERS);
9288 registry.register(&FOREST_ROCK);
9289 registry.register(&FOSSIL_COAL);
9290 registry.register(&FOSSIL_DIAMONDS);
9291 registry.register(&FREEZE_TOP_LAYER);
9292 registry.register(&GLOW_LICHEN);
9293 registry.register(&GLOWSTONE_EXTRA);
9294 registry.register(&GRASS);
9295 registry.register(&GRASS_JUNGLE);
9296 registry.register(&HUGE_BROWN_MUSHROOM);
9297 registry.register(&HUGE_RED_MUSHROOM);
9298 registry.register(&ICE_PATCH);
9299 registry.register(&ICE_SPIKE);
9300 registry.register(&ICEBERG_BLUE);
9301 registry.register(&ICEBERG_PACKED);
9302 registry.register(&JUNGLE_BUSH);
9303 registry.register(&JUNGLE_TREE);
9304 registry.register(&JUNGLE_TREE_NO_VINE);
9305 registry.register(&KELP);
9306 registry.register(&LAKE_LAVA);
9307 registry.register(&LARGE_BASALT_COLUMNS);
9308 registry.register(&LARGE_DRIPSTONE);
9309 registry.register(&LARGE_FERN);
9310 registry.register(&LEAF_LITTER);
9311 registry.register(&LUSH_CAVES_CLAY);
9312 registry.register(&MANGROVE);
9313 registry.register(&MANGROVE_VEGETATION);
9314 registry.register(&MEADOW_TREES);
9315 registry.register(&MEGA_JUNGLE_TREE);
9316 registry.register(&MEGA_PINE);
9317 registry.register(&MEGA_SPRUCE);
9318 registry.register(&MELON);
9319 registry.register(&MONSTER_ROOM);
9320 registry.register(&MOSS_PATCH);
9321 registry.register(&MOSS_PATCH_BONEMEAL);
9322 registry.register(&MOSS_PATCH_CEILING);
9323 registry.register(&MOSS_VEGETATION);
9324 registry.register(&MUSHROOM_ISLAND_VEGETATION);
9325 registry.register(&NETHER_SPROUTS);
9326 registry.register(&NETHER_SPROUTS_BONEMEAL);
9327 registry.register(&OAK);
9328 registry.register(&OAK_BEES_0002_LEAF_LITTER);
9329 registry.register(&OAK_BEES_002);
9330 registry.register(&OAK_BEES_005);
9331 registry.register(&OAK_LEAF_LITTER);
9332 registry.register(&ORE_ANCIENT_DEBRIS_LARGE);
9333 registry.register(&ORE_ANCIENT_DEBRIS_SMALL);
9334 registry.register(&ORE_ANDESITE);
9335 registry.register(&ORE_BLACKSTONE);
9336 registry.register(&ORE_CLAY);
9337 registry.register(&ORE_COAL);
9338 registry.register(&ORE_COAL_BURIED);
9339 registry.register(&ORE_COPPER_LARGE);
9340 registry.register(&ORE_COPPER_SMALL);
9341 registry.register(&ORE_DIAMOND_BURIED);
9342 registry.register(&ORE_DIAMOND_LARGE);
9343 registry.register(&ORE_DIAMOND_MEDIUM);
9344 registry.register(&ORE_DIAMOND_SMALL);
9345 registry.register(&ORE_DIORITE);
9346 registry.register(&ORE_DIRT);
9347 registry.register(&ORE_EMERALD);
9348 registry.register(&ORE_GOLD);
9349 registry.register(&ORE_GOLD_BURIED);
9350 registry.register(&ORE_GRANITE);
9351 registry.register(&ORE_GRAVEL);
9352 registry.register(&ORE_GRAVEL_NETHER);
9353 registry.register(&ORE_INFESTED);
9354 registry.register(&ORE_IRON);
9355 registry.register(&ORE_IRON_SMALL);
9356 registry.register(&ORE_LAPIS);
9357 registry.register(&ORE_LAPIS_BURIED);
9358 registry.register(&ORE_MAGMA);
9359 registry.register(&ORE_NETHER_GOLD);
9360 registry.register(&ORE_QUARTZ);
9361 registry.register(&ORE_REDSTONE);
9362 registry.register(&ORE_SOUL_SAND);
9363 registry.register(&ORE_TUFF);
9364 registry.register(&PALE_FOREST_FLOWER);
9365 registry.register(&PALE_GARDEN_VEGETATION);
9366 registry.register(&PALE_MOSS_PATCH);
9367 registry.register(&PALE_MOSS_PATCH_BONEMEAL);
9368 registry.register(&PALE_MOSS_VEGETATION);
9369 registry.register(&PALE_OAK);
9370 registry.register(&PALE_OAK_BONEMEAL);
9371 registry.register(&PALE_OAK_CREAKING);
9372 registry.register(&PATCH_FIRE);
9373 registry.register(&PATCH_SOUL_FIRE);
9374 registry.register(&PILE_HAY);
9375 registry.register(&PILE_ICE);
9376 registry.register(&PILE_MELON);
9377 registry.register(&PILE_PUMPKIN);
9378 registry.register(&PILE_SNOW);
9379 registry.register(&PINE);
9380 registry.register(&POINTED_DRIPSTONE);
9381 registry.register(&PUMPKIN);
9382 registry.register(&RED_MUSHROOM);
9383 registry.register(&ROOTED_AZALEA_TREE);
9384 registry.register(&SCULK_PATCH_ANCIENT_CITY);
9385 registry.register(&SCULK_PATCH_DEEP_DARK);
9386 registry.register(&SCULK_VEIN);
9387 registry.register(&SEA_PICKLE);
9388 registry.register(&SEAGRASS_MID);
9389 registry.register(&SEAGRASS_SHORT);
9390 registry.register(&SEAGRASS_SLIGHTLY_LESS_SHORT);
9391 registry.register(&SEAGRASS_TALL);
9392 registry.register(&SMALL_BASALT_COLUMNS);
9393 registry.register(&SPORE_BLOSSOM);
9394 registry.register(&SPRING_LAVA_FROZEN);
9395 registry.register(&SPRING_LAVA_NETHER);
9396 registry.register(&SPRING_LAVA_OVERWORLD);
9397 registry.register(&SPRING_NETHER_CLOSED);
9398 registry.register(&SPRING_NETHER_OPEN);
9399 registry.register(&SPRING_WATER);
9400 registry.register(&SPRUCE);
9401 registry.register(&SUGAR_CANE);
9402 registry.register(&SUNFLOWER);
9403 registry.register(&SUPER_BIRCH_BEES);
9404 registry.register(&SUPER_BIRCH_BEES_0002);
9405 registry.register(&SWAMP_OAK);
9406 registry.register(&TAIGA_GRASS);
9407 registry.register(&TALL_GRASS);
9408 registry.register(&TALL_MANGROVE);
9409 registry.register(&TREES_BADLANDS);
9410 registry.register(&TREES_BIRCH);
9411 registry.register(&TREES_BIRCH_AND_OAK_LEAF_LITTER);
9412 registry.register(&TREES_FLOWER_FOREST);
9413 registry.register(&TREES_GROVE);
9414 registry.register(&TREES_JUNGLE);
9415 registry.register(&TREES_OLD_GROWTH_PINE_TAIGA);
9416 registry.register(&TREES_OLD_GROWTH_SPRUCE_TAIGA);
9417 registry.register(&TREES_PLAINS);
9418 registry.register(&TREES_SAVANNA);
9419 registry.register(&TREES_SNOWY);
9420 registry.register(&TREES_SPARSE_JUNGLE);
9421 registry.register(&TREES_TAIGA);
9422 registry.register(&TREES_WATER);
9423 registry.register(&TREES_WINDSWEPT_HILLS);
9424 registry.register(&TWISTING_VINES);
9425 registry.register(&TWISTING_VINES_BONEMEAL);
9426 registry.register(&UNDERWATER_MAGMA);
9427 registry.register(&VINES);
9428 registry.register(&VOID_START_PLATFORM);
9429 registry.register(&WARM_OCEAN_VEGETATION);
9430 registry.register(&WARPED_FOREST_VEGETATION);
9431 registry.register(&WARPED_FOREST_VEGETATION_BONEMEAL);
9432 registry.register(&WARPED_FUNGUS);
9433 registry.register(&WARPED_FUNGUS_PLANTED);
9434 registry.register(&WATERLILY);
9435 registry.register(&WEEPING_VINES);
9436 registry.register(&WILDFLOWER);
9437}