1use crate::{feature::*, vanilla_blocks, vanilla_fluids};
2use steel_utils::Identifier;
3use steel_utils::value_providers::IntProvider;
4use std::sync::{LazyLock, OnceLock};
5use simdnbt::owned::{NbtCompound, NbtList, NbtTag};
6use glam::IVec3;
7fn cave_vines_body_nbt() -> NbtCompound {
8 let NbtTag::Compound(compound) = ({
9 let mut compound = NbtCompound::new();
10 compound.insert("type", "minecraft:weighted");
11 compound
12 .insert(
13 "entries",
14 NbtTag::List(
15 NbtList::from(
16 vec![
17 { let mut compound = NbtCompound::new(); compound
18 .insert("data", { let mut compound = NbtCompound::new();
19 compound.insert("id",
20 NbtTag::String("minecraft:cave_vines_plant".into()));
21 NbtTag::Compound(compound) }); compound.insert("weight",
22 4i32); NbtTag::Compound(compound) }, { let mut compound =
23 NbtCompound::new(); compound.insert("data", { let mut
24 compound = NbtCompound::new(); compound.insert("id",
25 NbtTag::String("minecraft:cave_vines_plant".into())); let mut
26 properties = NbtCompound::new(); properties.insert("berries",
27 "true"); compound.insert("properties",
28 NbtTag::Compound(properties)); NbtTag::Compound(compound) });
29 compound.insert("weight", 1i32); NbtTag::Compound(compound) }
30 ],
31 ),
32 ),
33 );
34 NbtTag::Compound(compound)
35 }) else {
36 unreachable!("block state provider registry entries always encode as a compound")
37 };
38 compound
39}
40pub static CAVE_VINES_BODY: LazyLock<BlockStateProvider> = LazyLock::new(|| {
41 BlockStateProvider {
42 key: Identifier::vanilla_static("cave_vines_body"),
43 kind: BlockStateProviderKind::Weighted {
44 entries: vec![
45 WeightedBlockState { data : BlockStateData { block : &
46 vanilla_blocks::CAVE_VINES_PLANT, properties : & [], }, weight : 4i32 },
47 WeightedBlockState { data : BlockStateData { block : &
48 vanilla_blocks::CAVE_VINES_PLANT, properties : & [("berries", "true")],
49 }, weight : 1i32 }
50 ],
51 },
52 nbt: cave_vines_body_nbt,
53 id: OnceLock::new(),
54 }
55});
56fn cave_vines_head_nbt() -> NbtCompound {
57 let NbtTag::Compound(compound) = ({
58 let mut compound = NbtCompound::new();
59 compound.insert("type", "minecraft:randomized_int");
60 compound.insert("property", "age");
61 compound
62 .insert(
63 "source",
64 {
65 let mut compound = NbtCompound::new();
66 compound.insert("type", "minecraft:weighted");
67 compound
68 .insert(
69 "entries",
70 NbtTag::List(
71 NbtList::from(
72 vec![
73 { let mut compound = NbtCompound::new(); compound
74 .insert("data", { let mut compound = NbtCompound::new();
75 compound.insert("id", NbtTag::String("minecraft:cave_vines"
76 .into())); NbtTag::Compound(compound) }); compound
77 .insert("weight", 4i32); NbtTag::Compound(compound) }, { let
78 mut compound = NbtCompound::new(); compound.insert("data", {
79 let mut compound = NbtCompound::new(); compound.insert("id",
80 NbtTag::String("minecraft:cave_vines".into())); let mut
81 properties = NbtCompound::new(); properties.insert("age",
82 "0"); properties.insert("berries", "true"); compound
83 .insert("properties", NbtTag::Compound(properties));
84 NbtTag::Compound(compound) }); compound.insert("weight",
85 1i32); NbtTag::Compound(compound) }
86 ],
87 ),
88 ),
89 );
90 NbtTag::Compound(compound)
91 },
92 );
93 compound
94 .insert(
95 "values",
96 {
97 let mut compound = NbtCompound::new();
98 compound.insert("type", "minecraft:uniform");
99 compound.insert("min_inclusive", 23i32);
100 compound.insert("max_inclusive", 25i32);
101 NbtTag::Compound(compound)
102 },
103 );
104 NbtTag::Compound(compound)
105 }) else {
106 unreachable!("block state provider registry entries always encode as a compound")
107 };
108 compound
109}
110pub static CAVE_VINES_HEAD: LazyLock<BlockStateProvider> = LazyLock::new(|| {
111 BlockStateProvider {
112 key: Identifier::vanilla_static("cave_vines_head"),
113 kind: BlockStateProviderKind::RandomizedInt {
114 property: "age".to_string(),
115 source: Box::new(BlockStateProviderKind::Weighted {
116 entries: vec![
117 WeightedBlockState { data : BlockStateData { block : &
118 vanilla_blocks::CAVE_VINES, properties : & [], }, weight : 4i32 },
119 WeightedBlockState { data : BlockStateData { block : &
120 vanilla_blocks::CAVE_VINES, properties : & [("age", "0"), ("berries",
121 "true")], }, weight : 1i32 }
122 ],
123 }),
124 values: IntProvider::Uniform {
125 min_inclusive: 23i32,
126 max_inclusive: 25i32,
127 },
128 },
129 nbt: cave_vines_head_nbt,
130 id: OnceLock::new(),
131 }
132});
133fn flower_flower_forest_nbt() -> NbtCompound {
134 let NbtTag::Compound(compound) = ({
135 let mut compound = NbtCompound::new();
136 compound.insert("type", "minecraft:noise");
137 compound
138 .insert(
139 "noise",
140 {
141 let mut compound = NbtCompound::new();
142 compound.insert("base_amplitude", 0.955388882960065f64);
143 compound.insert("base_octave", 0i32);
144 compound.insert("octave_count", 1i32);
145 compound.insert("normalize", NbtTag::Byte(1i8));
146 compound.insert("amplitude_modifiers", NbtTag::List(NbtList::Empty));
147 NbtTag::Compound(compound)
148 },
149 );
150 compound.insert("scale", 0.020833334f32);
151 compound.insert("seed", 2345i64);
152 compound
153 .insert(
154 "states",
155 NbtTag::List(
156 NbtList::from(
157 vec![
158 { let mut compound = NbtCompound::new(); compound
159 .insert("id", NbtTag::String("minecraft:dandelion".into()));
160 NbtTag::Compound(compound) }, { let mut compound =
161 NbtCompound::new(); compound.insert("id",
162 NbtTag::String("minecraft:poppy".into()));
163 NbtTag::Compound(compound) }, { let mut compound =
164 NbtCompound::new(); compound.insert("id",
165 NbtTag::String("minecraft:allium".into()));
166 NbtTag::Compound(compound) }, { let mut compound =
167 NbtCompound::new(); compound.insert("id",
168 NbtTag::String("minecraft:azure_bluet".into()));
169 NbtTag::Compound(compound) }, { let mut compound =
170 NbtCompound::new(); compound.insert("id",
171 NbtTag::String("minecraft:red_tulip".into()));
172 NbtTag::Compound(compound) }, { let mut compound =
173 NbtCompound::new(); compound.insert("id",
174 NbtTag::String("minecraft:orange_tulip".into()));
175 NbtTag::Compound(compound) }, { let mut compound =
176 NbtCompound::new(); compound.insert("id",
177 NbtTag::String("minecraft:white_tulip".into()));
178 NbtTag::Compound(compound) }, { let mut compound =
179 NbtCompound::new(); compound.insert("id",
180 NbtTag::String("minecraft:pink_tulip".into()));
181 NbtTag::Compound(compound) }, { let mut compound =
182 NbtCompound::new(); compound.insert("id",
183 NbtTag::String("minecraft:oxeye_daisy".into()));
184 NbtTag::Compound(compound) }, { let mut compound =
185 NbtCompound::new(); compound.insert("id",
186 NbtTag::String("minecraft:cornflower".into()));
187 NbtTag::Compound(compound) }, { let mut compound =
188 NbtCompound::new(); compound.insert("id",
189 NbtTag::String("minecraft:lily_of_the_valley".into()));
190 NbtTag::Compound(compound) }
191 ],
192 ),
193 ),
194 );
195 NbtTag::Compound(compound)
196 }) else {
197 unreachable!("block state provider registry entries always encode as a compound")
198 };
199 compound
200}
201pub static FLOWER_FLOWER_FOREST: LazyLock<BlockStateProvider> = LazyLock::new(|| {
202 BlockStateProvider {
203 key: Identifier::vanilla_static("flower_flower_forest"),
204 kind: BlockStateProviderKind::Noise(NoiseProvider {
205 noise: FeatureNoiseParameters {
206 base_amplitude: 0.955388882960065f64,
207 base_octave: 0i32,
208 octave_count: 1i32,
209 normalize: true,
210 amplitude_modifiers: vec![],
211 },
212 scale: 0.020833334f32,
213 seed: 2345i64,
214 states: vec![
215 BlockStateData { block : & vanilla_blocks::DANDELION, properties : & [],
216 }, BlockStateData { block : & vanilla_blocks::POPPY, properties : & [],
217 }, BlockStateData { block : & vanilla_blocks::ALLIUM, properties : & [],
218 }, BlockStateData { block : & vanilla_blocks::AZURE_BLUET, properties : &
219 [], }, BlockStateData { block : & vanilla_blocks::RED_TULIP, properties :
220 & [], }, BlockStateData { block : & vanilla_blocks::ORANGE_TULIP,
221 properties : & [], }, BlockStateData { block : &
222 vanilla_blocks::WHITE_TULIP, properties : & [], }, BlockStateData { block
223 : & vanilla_blocks::PINK_TULIP, properties : & [], }, BlockStateData {
224 block : & vanilla_blocks::OXEYE_DAISY, properties : & [], },
225 BlockStateData { block : & vanilla_blocks::CORNFLOWER, properties : & [],
226 }, BlockStateData { block : & vanilla_blocks::LILY_OF_THE_VALLEY,
227 properties : & [], }
228 ],
229 }),
230 nbt: flower_flower_forest_nbt,
231 id: OnceLock::new(),
232 }
233});
234fn flower_meadow_nbt() -> NbtCompound {
235 let NbtTag::Compound(compound) = ({
236 let mut compound = NbtCompound::new();
237 compound.insert("type", "minecraft:dual_noise");
238 compound
239 .insert(
240 "noise",
241 {
242 let mut compound = NbtCompound::new();
243 compound.insert("base_amplitude", 0.955388882960065f64);
244 compound.insert("base_octave", -3i32);
245 compound.insert("octave_count", 1i32);
246 compound.insert("normalize", NbtTag::Byte(1i8));
247 compound.insert("amplitude_modifiers", NbtTag::List(NbtList::Empty));
248 NbtTag::Compound(compound)
249 },
250 );
251 compound.insert("scale", 1f32);
252 compound.insert("seed", 2345i64);
253 compound
254 .insert(
255 "slow_noise",
256 {
257 let mut compound = NbtCompound::new();
258 compound.insert("base_amplitude", 0.955388882960065f64);
259 compound.insert("base_octave", -10i32);
260 compound.insert("octave_count", 1i32);
261 compound.insert("normalize", NbtTag::Byte(1i8));
262 compound.insert("amplitude_modifiers", NbtTag::List(NbtList::Empty));
263 NbtTag::Compound(compound)
264 },
265 );
266 compound.insert("slow_scale", 1f32);
267 compound
268 .insert(
269 "states",
270 NbtTag::List(
271 NbtList::from(
272 vec![
273 { let mut compound = NbtCompound::new(); compound
274 .insert("id", NbtTag::String("minecraft:tall_grass".into()));
275 NbtTag::Compound(compound) }, { let mut compound =
276 NbtCompound::new(); compound.insert("id",
277 NbtTag::String("minecraft:allium".into()));
278 NbtTag::Compound(compound) }, { let mut compound =
279 NbtCompound::new(); compound.insert("id",
280 NbtTag::String("minecraft:poppy".into()));
281 NbtTag::Compound(compound) }, { let mut compound =
282 NbtCompound::new(); compound.insert("id",
283 NbtTag::String("minecraft:azure_bluet".into()));
284 NbtTag::Compound(compound) }, { let mut compound =
285 NbtCompound::new(); compound.insert("id",
286 NbtTag::String("minecraft:dandelion".into()));
287 NbtTag::Compound(compound) }, { let mut compound =
288 NbtCompound::new(); compound.insert("id",
289 NbtTag::String("minecraft:cornflower".into()));
290 NbtTag::Compound(compound) }, { let mut compound =
291 NbtCompound::new(); compound.insert("id",
292 NbtTag::String("minecraft:oxeye_daisy".into()));
293 NbtTag::Compound(compound) }, { let mut compound =
294 NbtCompound::new(); compound.insert("id",
295 NbtTag::String("minecraft:short_grass".into()));
296 NbtTag::Compound(compound) }
297 ],
298 ),
299 ),
300 );
301 compound.insert("variety", NbtTag::IntArray(vec![1i32, 3i32]));
302 NbtTag::Compound(compound)
303 }) else {
304 unreachable!("block state provider registry entries always encode as a compound")
305 };
306 compound
307}
308pub static FLOWER_MEADOW: LazyLock<BlockStateProvider> = LazyLock::new(|| {
309 BlockStateProvider {
310 key: Identifier::vanilla_static("flower_meadow"),
311 kind: BlockStateProviderKind::DualNoise(DualNoiseProvider {
312 noise: FeatureNoiseParameters {
313 base_amplitude: 0.955388882960065f64,
314 base_octave: -3i32,
315 octave_count: 1i32,
316 normalize: true,
317 amplitude_modifiers: vec![],
318 },
319 scale: 1f32,
320 seed: 2345i64,
321 slow_noise: FeatureNoiseParameters {
322 base_amplitude: 0.955388882960065f64,
323 base_octave: -10i32,
324 octave_count: 1i32,
325 normalize: true,
326 amplitude_modifiers: vec![],
327 },
328 slow_scale: 1f32,
329 states: vec![
330 BlockStateData { block : & vanilla_blocks::TALL_GRASS, properties : & [],
331 }, BlockStateData { block : & vanilla_blocks::ALLIUM, properties : & [],
332 }, BlockStateData { block : & vanilla_blocks::POPPY, properties : & [],
333 }, BlockStateData { block : & vanilla_blocks::AZURE_BLUET, properties : &
334 [], }, BlockStateData { block : & vanilla_blocks::DANDELION, properties :
335 & [], }, BlockStateData { block : & vanilla_blocks::CORNFLOWER,
336 properties : & [], }, BlockStateData { block : &
337 vanilla_blocks::OXEYE_DAISY, properties : & [], }, BlockStateData { block
338 : & vanilla_blocks::SHORT_GRASS, properties : & [], }
339 ],
340 variety: [1i32, 3i32],
341 }),
342 nbt: flower_meadow_nbt,
343 id: OnceLock::new(),
344 }
345});
346fn flower_plain_nbt() -> NbtCompound {
347 let NbtTag::Compound(compound) = ({
348 let mut compound = NbtCompound::new();
349 compound.insert("type", "minecraft:noise_threshold");
350 compound
351 .insert(
352 "noise",
353 {
354 let mut compound = NbtCompound::new();
355 compound.insert("base_amplitude", 0.955388882960065f64);
356 compound.insert("base_octave", 0i32);
357 compound.insert("octave_count", 1i32);
358 compound.insert("normalize", NbtTag::Byte(1i8));
359 compound.insert("amplitude_modifiers", NbtTag::List(NbtList::Empty));
360 NbtTag::Compound(compound)
361 },
362 );
363 compound.insert("scale", 0.005f32);
364 compound.insert("seed", 2345i64);
365 compound.insert("threshold", -0.8f32);
366 compound.insert("high_chance", 0.33333334f32);
367 compound
368 .insert(
369 "default_state",
370 {
371 let mut compound = NbtCompound::new();
372 compound.insert("id", NbtTag::String("minecraft:dandelion".into()));
373 NbtTag::Compound(compound)
374 },
375 );
376 compound
377 .insert(
378 "low_states",
379 NbtTag::List(
380 NbtList::from(
381 vec![
382 { let mut compound = NbtCompound::new(); compound
383 .insert("id", NbtTag::String("minecraft:orange_tulip"
384 .into())); NbtTag::Compound(compound) }, { let mut compound =
385 NbtCompound::new(); compound.insert("id",
386 NbtTag::String("minecraft:red_tulip".into()));
387 NbtTag::Compound(compound) }, { let mut compound =
388 NbtCompound::new(); compound.insert("id",
389 NbtTag::String("minecraft:pink_tulip".into()));
390 NbtTag::Compound(compound) }, { let mut compound =
391 NbtCompound::new(); compound.insert("id",
392 NbtTag::String("minecraft:white_tulip".into()));
393 NbtTag::Compound(compound) }
394 ],
395 ),
396 ),
397 );
398 compound
399 .insert(
400 "high_states",
401 NbtTag::List(
402 NbtList::from(
403 vec![
404 { let mut compound = NbtCompound::new(); compound
405 .insert("id", NbtTag::String("minecraft:poppy".into()));
406 NbtTag::Compound(compound) }, { let mut compound =
407 NbtCompound::new(); compound.insert("id",
408 NbtTag::String("minecraft:azure_bluet".into()));
409 NbtTag::Compound(compound) }, { let mut compound =
410 NbtCompound::new(); compound.insert("id",
411 NbtTag::String("minecraft:oxeye_daisy".into()));
412 NbtTag::Compound(compound) }, { let mut compound =
413 NbtCompound::new(); compound.insert("id",
414 NbtTag::String("minecraft:cornflower".into()));
415 NbtTag::Compound(compound) }
416 ],
417 ),
418 ),
419 );
420 NbtTag::Compound(compound)
421 }) else {
422 unreachable!("block state provider registry entries always encode as a compound")
423 };
424 compound
425}
426pub static FLOWER_PLAIN: LazyLock<BlockStateProvider> = LazyLock::new(|| {
427 BlockStateProvider {
428 key: Identifier::vanilla_static("flower_plain"),
429 kind: BlockStateProviderKind::NoiseThreshold(NoiseThresholdProvider {
430 noise: FeatureNoiseParameters {
431 base_amplitude: 0.955388882960065f64,
432 base_octave: 0i32,
433 octave_count: 1i32,
434 normalize: true,
435 amplitude_modifiers: vec![],
436 },
437 scale: 0.005f32,
438 seed: 2345i64,
439 threshold: -0.8f32,
440 high_chance: 0.33333334f32,
441 default_state: BlockStateData {
442 block: &vanilla_blocks::DANDELION,
443 properties: &[],
444 },
445 low_states: vec![
446 BlockStateData { block : & vanilla_blocks::ORANGE_TULIP, properties : &
447 [], }, BlockStateData { block : & vanilla_blocks::RED_TULIP, properties :
448 & [], }, BlockStateData { block : & vanilla_blocks::PINK_TULIP,
449 properties : & [], }, BlockStateData { block : &
450 vanilla_blocks::WHITE_TULIP, properties : & [], }
451 ],
452 high_states: vec![
453 BlockStateData { block : & vanilla_blocks::POPPY, properties : & [], },
454 BlockStateData { block : & vanilla_blocks::AZURE_BLUET, properties : &
455 [], }, BlockStateData { block : & vanilla_blocks::OXEYE_DAISY, properties
456 : & [], }, BlockStateData { block : & vanilla_blocks::CORNFLOWER,
457 properties : & [], }
458 ],
459 }),
460 nbt: flower_plain_nbt,
461 id: OnceLock::new(),
462 }
463});
464fn mangrove_propagule_nbt() -> NbtCompound {
465 let NbtTag::Compound(compound) = ({
466 let mut compound = NbtCompound::new();
467 compound.insert("type", "minecraft:randomized_int");
468 compound.insert("property", "age");
469 compound
470 .insert(
471 "source",
472 {
473 let mut compound = NbtCompound::new();
474 compound
475 .insert(
476 "id",
477 NbtTag::String("minecraft:mangrove_propagule".into()),
478 );
479 let mut properties = NbtCompound::new();
480 properties.insert("age", "0");
481 properties.insert("hanging", "true");
482 properties.insert("stage", "0");
483 properties.insert("waterlogged", "false");
484 compound.insert("properties", NbtTag::Compound(properties));
485 NbtTag::Compound(compound)
486 },
487 );
488 compound
489 .insert(
490 "values",
491 {
492 let mut compound = NbtCompound::new();
493 compound.insert("type", "minecraft:uniform");
494 compound.insert("min_inclusive", 0i32);
495 compound.insert("max_inclusive", 4i32);
496 NbtTag::Compound(compound)
497 },
498 );
499 NbtTag::Compound(compound)
500 }) else {
501 unreachable!("block state provider registry entries always encode as a compound")
502 };
503 compound
504}
505pub static MANGROVE_PROPAGULE: LazyLock<BlockStateProvider> = LazyLock::new(|| {
506 BlockStateProvider {
507 key: Identifier::vanilla_static("mangrove_propagule"),
508 kind: BlockStateProviderKind::RandomizedInt {
509 property: "age".to_string(),
510 source: Box::new(BlockStateProviderKind::Simple {
511 state: BlockStateData {
512 block: &vanilla_blocks::MANGROVE_PROPAGULE,
513 properties: &[
514 ("age", "0"),
515 ("hanging", "true"),
516 ("stage", "0"),
517 ("waterlogged", "false"),
518 ],
519 },
520 }),
521 values: IntProvider::Uniform {
522 min_inclusive: 0i32,
523 max_inclusive: 4i32,
524 },
525 },
526 nbt: mangrove_propagule_nbt,
527 id: OnceLock::new(),
528 }
529});
530fn podzol_beneath_tree_nbt() -> NbtCompound {
531 let NbtTag::Compound(compound) = ({
532 let mut compound = NbtCompound::new();
533 compound.insert("type", "minecraft:rule_based");
534 compound
535 .insert(
536 "rules",
537 NbtTag::List(
538 NbtList::from(
539 vec![
540 { let mut compound = NbtCompound::new(); compound
541 .insert("if_true", { let mut compound = NbtCompound::new();
542 compound.insert("type", "minecraft:matching_block_tag");
543 compound.insert("tag",
544 "minecraft:beneath_tree_podzol_replaceable");
545 NbtTag::Compound(compound) }); compound.insert("then", { let
546 mut compound = NbtCompound::new(); compound.insert("id",
547 NbtTag::String("minecraft:podzol".into())); let mut
548 properties = NbtCompound::new(); properties.insert("snowy",
549 "false"); compound.insert("properties",
550 NbtTag::Compound(properties)); NbtTag::Compound(compound) });
551 NbtTag::Compound(compound) }
552 ],
553 ),
554 ),
555 );
556 NbtTag::Compound(compound)
557 }) else {
558 unreachable!("block state provider registry entries always encode as a compound")
559 };
560 compound
561}
562pub static PODZOL_BENEATH_TREE: LazyLock<BlockStateProvider> = LazyLock::new(|| {
563 BlockStateProvider {
564 key: Identifier::vanilla_static("podzol_beneath_tree"),
565 kind: BlockStateProviderKind::RuleBased {
566 fallback: None,
567 rules: vec![
568 RuleBasedStateProviderRule { if_true : BlockPredicate::MatchingBlockTag {
569 tag : Identifier::vanilla_static("beneath_tree_podzol_replaceable"),
570 offset : IVec3::new(0i32, 0i32, 0i32) }, then :
571 BlockStateProviderKind::Simple { state : BlockStateData { block : &
572 vanilla_blocks::PODZOL, properties : & [("snowy", "false")], } }, }
573 ],
574 },
575 nbt: podzol_beneath_tree_nbt,
576 id: OnceLock::new(),
577 }
578});
579fn soil_beneath_tree_nbt() -> NbtCompound {
580 let NbtTag::Compound(compound) = ({
581 let mut compound = NbtCompound::new();
582 compound.insert("type", "minecraft:rule_based");
583 compound
584 .insert(
585 "rules",
586 NbtTag::List(
587 NbtList::from(
588 vec![
589 { let mut compound = NbtCompound::new(); compound
590 .insert("if_true", { let mut compound = NbtCompound::new();
591 compound.insert("type", "minecraft:not"); compound
592 .insert("predicate", { let mut compound = NbtCompound::new();
593 compound.insert("type", "minecraft:matching_block_tag");
594 compound.insert("tag",
595 "minecraft:cannot_replace_below_tree_trunk");
596 NbtTag::Compound(compound) }); NbtTag::Compound(compound) });
597 compound.insert("then", { let mut compound =
598 NbtCompound::new(); compound.insert("id",
599 NbtTag::String("minecraft:dirt".into()));
600 NbtTag::Compound(compound) }); NbtTag::Compound(compound) }
601 ],
602 ),
603 ),
604 );
605 NbtTag::Compound(compound)
606 }) else {
607 unreachable!("block state provider registry entries always encode as a compound")
608 };
609 compound
610}
611pub static SOIL_BENEATH_TREE: LazyLock<BlockStateProvider> = LazyLock::new(|| {
612 BlockStateProvider {
613 key: Identifier::vanilla_static("soil_beneath_tree"),
614 kind: BlockStateProviderKind::RuleBased {
615 fallback: None,
616 rules: vec![
617 RuleBasedStateProviderRule { if_true : BlockPredicate::Not { predicate :
618 Box::new(BlockPredicate::MatchingBlockTag { tag :
619 Identifier::vanilla_static("cannot_replace_below_tree_trunk"), offset :
620 IVec3::new(0i32, 0i32, 0i32) }) }, then : BlockStateProviderKind::Simple
621 { state : BlockStateData { block : & vanilla_blocks::DIRT, properties : &
622 [], } }, }
623 ],
624 },
625 nbt: soil_beneath_tree_nbt,
626 id: OnceLock::new(),
627 }
628});
629pub fn register_block_state_providers(registry: &mut BlockStateProviderRegistry) {
630 registry.register(&CAVE_VINES_BODY);
631 registry.register(&CAVE_VINES_HEAD);
632 registry.register(&FLOWER_FLOWER_FOREST);
633 registry.register(&FLOWER_MEADOW);
634 registry.register(&FLOWER_PLAIN);
635 registry.register(&MANGROVE_PROPAGULE);
636 registry.register(&PODZOL_BENEATH_TREE);
637 registry.register(&SOIL_BENEATH_TREE);
638}