1use crate::shared_structs::BlockStateData;
2use crate::structure_processor::{
3 PosRuleTestData, ProcessorRuleData, RuleBlockEntityModifierData, StructureProcessorAxis,
4 StructureProcessorKind, StructureProcessorList, StructureProcessorListData,
5 StructureProcessorListRegistry, StructureRuleTestData,
6};
7use std::sync::{LazyLock, OnceLock};
8use steel_utils::value_providers::IntProvider;
9use steel_utils::Identifier;
10pub static ANCIENT_CITY_GENERIC_DEGRADATION: LazyLock<StructureProcessorList> =
11 LazyLock::new(|| StructureProcessorList {
12 key: Identifier::vanilla_static("ancient_city_generic_degradation"),
13 data: StructureProcessorListData {
14 processors: vec![
15 StructureProcessorKind::BlockRot {
16 rottable_blocks: Some(Identifier::vanilla_static("ancient_city_replaceable")),
17 integrity: 0.95f32,
18 },
19 StructureProcessorKind::Rule {
20 rules: vec![
21 ProcessorRuleData {
22 input_predicate: StructureRuleTestData::RandomBlockMatch {
23 block: Identifier::vanilla_static("deepslate_bricks"),
24 probability: 0.3f32,
25 },
26 location_predicate: StructureRuleTestData::AlwaysTrue,
27 position_predicate: PosRuleTestData::AlwaysTrue,
28 output_state: BlockStateData {
29 name: Identifier::vanilla_static("cracked_deepslate_bricks"),
30 properties: std::collections::BTreeMap::new(),
31 },
32 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
33 },
34 ProcessorRuleData {
35 input_predicate: StructureRuleTestData::RandomBlockMatch {
36 block: Identifier::vanilla_static("deepslate_tiles"),
37 probability: 0.3f32,
38 },
39 location_predicate: StructureRuleTestData::AlwaysTrue,
40 position_predicate: PosRuleTestData::AlwaysTrue,
41 output_state: BlockStateData {
42 name: Identifier::vanilla_static("cracked_deepslate_tiles"),
43 properties: std::collections::BTreeMap::new(),
44 },
45 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
46 },
47 ProcessorRuleData {
48 input_predicate: StructureRuleTestData::RandomBlockMatch {
49 block: Identifier::vanilla_static("soul_lantern"),
50 probability: 0.05f32,
51 },
52 location_predicate: StructureRuleTestData::AlwaysTrue,
53 position_predicate: PosRuleTestData::AlwaysTrue,
54 output_state: BlockStateData {
55 name: Identifier::vanilla_static("air"),
56 properties: std::collections::BTreeMap::new(),
57 },
58 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
59 },
60 ],
61 },
62 StructureProcessorKind::ProtectedBlocks {
63 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
64 },
65 ],
66 },
67 id: OnceLock::new(),
68 });
69pub static ANCIENT_CITY_START_DEGRADATION: LazyLock<StructureProcessorList> =
70 LazyLock::new(|| StructureProcessorList {
71 key: Identifier::vanilla_static("ancient_city_start_degradation"),
72 data: StructureProcessorListData {
73 processors: vec![
74 StructureProcessorKind::Rule {
75 rules: vec![
76 ProcessorRuleData {
77 input_predicate: StructureRuleTestData::RandomBlockMatch {
78 block: Identifier::vanilla_static("deepslate_bricks"),
79 probability: 0.3f32,
80 },
81 location_predicate: StructureRuleTestData::AlwaysTrue,
82 position_predicate: PosRuleTestData::AlwaysTrue,
83 output_state: BlockStateData {
84 name: Identifier::vanilla_static("cracked_deepslate_bricks"),
85 properties: std::collections::BTreeMap::new(),
86 },
87 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
88 },
89 ProcessorRuleData {
90 input_predicate: StructureRuleTestData::RandomBlockMatch {
91 block: Identifier::vanilla_static("deepslate_tiles"),
92 probability: 0.3f32,
93 },
94 location_predicate: StructureRuleTestData::AlwaysTrue,
95 position_predicate: PosRuleTestData::AlwaysTrue,
96 output_state: BlockStateData {
97 name: Identifier::vanilla_static("cracked_deepslate_tiles"),
98 properties: std::collections::BTreeMap::new(),
99 },
100 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
101 },
102 ProcessorRuleData {
103 input_predicate: StructureRuleTestData::RandomBlockMatch {
104 block: Identifier::vanilla_static("soul_lantern"),
105 probability: 0.05f32,
106 },
107 location_predicate: StructureRuleTestData::AlwaysTrue,
108 position_predicate: PosRuleTestData::AlwaysTrue,
109 output_state: BlockStateData {
110 name: Identifier::vanilla_static("air"),
111 properties: std::collections::BTreeMap::new(),
112 },
113 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
114 },
115 ],
116 },
117 StructureProcessorKind::ProtectedBlocks {
118 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
119 },
120 ],
121 },
122 id: OnceLock::new(),
123 });
124pub static ANCIENT_CITY_WALLS_DEGRADATION: LazyLock<StructureProcessorList> =
125 LazyLock::new(|| StructureProcessorList {
126 key: Identifier::vanilla_static("ancient_city_walls_degradation"),
127 data: StructureProcessorListData {
128 processors: vec![
129 StructureProcessorKind::BlockRot {
130 rottable_blocks: Some(Identifier::vanilla_static("ancient_city_replaceable")),
131 integrity: 0.95f32,
132 },
133 StructureProcessorKind::Rule {
134 rules: vec![
135 ProcessorRuleData {
136 input_predicate: StructureRuleTestData::RandomBlockMatch {
137 block: Identifier::vanilla_static("deepslate_bricks"),
138 probability: 0.3f32,
139 },
140 location_predicate: StructureRuleTestData::AlwaysTrue,
141 position_predicate: PosRuleTestData::AlwaysTrue,
142 output_state: BlockStateData {
143 name: Identifier::vanilla_static("cracked_deepslate_bricks"),
144 properties: std::collections::BTreeMap::new(),
145 },
146 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
147 },
148 ProcessorRuleData {
149 input_predicate: StructureRuleTestData::RandomBlockMatch {
150 block: Identifier::vanilla_static("deepslate_tiles"),
151 probability: 0.3f32,
152 },
153 location_predicate: StructureRuleTestData::AlwaysTrue,
154 position_predicate: PosRuleTestData::AlwaysTrue,
155 output_state: BlockStateData {
156 name: Identifier::vanilla_static("cracked_deepslate_tiles"),
157 properties: std::collections::BTreeMap::new(),
158 },
159 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
160 },
161 ProcessorRuleData {
162 input_predicate: StructureRuleTestData::RandomBlockMatch {
163 block: Identifier::vanilla_static("deepslate_tile_slab"),
164 probability: 0.3f32,
165 },
166 location_predicate: StructureRuleTestData::AlwaysTrue,
167 position_predicate: PosRuleTestData::AlwaysTrue,
168 output_state: BlockStateData {
169 name: Identifier::vanilla_static("air"),
170 properties: std::collections::BTreeMap::new(),
171 },
172 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
173 },
174 ProcessorRuleData {
175 input_predicate: StructureRuleTestData::RandomBlockMatch {
176 block: Identifier::vanilla_static("soul_lantern"),
177 probability: 0.05f32,
178 },
179 location_predicate: StructureRuleTestData::AlwaysTrue,
180 position_predicate: PosRuleTestData::AlwaysTrue,
181 output_state: BlockStateData {
182 name: Identifier::vanilla_static("air"),
183 properties: std::collections::BTreeMap::new(),
184 },
185 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
186 },
187 ],
188 },
189 StructureProcessorKind::ProtectedBlocks {
190 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
191 },
192 ],
193 },
194 id: OnceLock::new(),
195 });
196pub static BASTION_GENERIC_DEGRADATION: LazyLock<StructureProcessorList> =
197 LazyLock::new(|| StructureProcessorList {
198 key: Identifier::vanilla_static("bastion_generic_degradation"),
199 data: StructureProcessorListData {
200 processors: vec![StructureProcessorKind::Rule {
201 rules: vec![
202 ProcessorRuleData {
203 input_predicate: StructureRuleTestData::RandomBlockMatch {
204 block: Identifier::vanilla_static("polished_blackstone_bricks"),
205 probability: 0.3f32,
206 },
207 location_predicate: StructureRuleTestData::AlwaysTrue,
208 position_predicate: PosRuleTestData::AlwaysTrue,
209 output_state: BlockStateData {
210 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
211 properties: std::collections::BTreeMap::new(),
212 },
213 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
214 },
215 ProcessorRuleData {
216 input_predicate: StructureRuleTestData::RandomBlockMatch {
217 block: Identifier::vanilla_static("blackstone"),
218 probability: 0.0001f32,
219 },
220 location_predicate: StructureRuleTestData::AlwaysTrue,
221 position_predicate: PosRuleTestData::AlwaysTrue,
222 output_state: BlockStateData {
223 name: Identifier::vanilla_static("air"),
224 properties: std::collections::BTreeMap::new(),
225 },
226 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
227 },
228 ProcessorRuleData {
229 input_predicate: StructureRuleTestData::RandomBlockMatch {
230 block: Identifier::vanilla_static("gold_block"),
231 probability: 0.3f32,
232 },
233 location_predicate: StructureRuleTestData::AlwaysTrue,
234 position_predicate: PosRuleTestData::AlwaysTrue,
235 output_state: BlockStateData {
236 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
237 properties: std::collections::BTreeMap::new(),
238 },
239 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
240 },
241 ProcessorRuleData {
242 input_predicate: StructureRuleTestData::RandomBlockMatch {
243 block: Identifier::vanilla_static("gilded_blackstone"),
244 probability: 0.5f32,
245 },
246 location_predicate: StructureRuleTestData::AlwaysTrue,
247 position_predicate: PosRuleTestData::AlwaysTrue,
248 output_state: BlockStateData {
249 name: Identifier::vanilla_static("blackstone"),
250 properties: std::collections::BTreeMap::new(),
251 },
252 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
253 },
254 ProcessorRuleData {
255 input_predicate: StructureRuleTestData::RandomBlockMatch {
256 block: Identifier::vanilla_static("blackstone"),
257 probability: 0.01f32,
258 },
259 location_predicate: StructureRuleTestData::AlwaysTrue,
260 position_predicate: PosRuleTestData::AlwaysTrue,
261 output_state: BlockStateData {
262 name: Identifier::vanilla_static("gilded_blackstone"),
263 properties: std::collections::BTreeMap::new(),
264 },
265 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
266 },
267 ],
268 }],
269 },
270 id: OnceLock::new(),
271 });
272pub static BOTTOM_RAMPART: LazyLock<StructureProcessorList> =
273 LazyLock::new(|| StructureProcessorList {
274 key: Identifier::vanilla_static("bottom_rampart"),
275 data: StructureProcessorListData {
276 processors: vec![StructureProcessorKind::Rule {
277 rules: vec![
278 ProcessorRuleData {
279 input_predicate: StructureRuleTestData::RandomBlockMatch {
280 block: Identifier::vanilla_static("magma_block"),
281 probability: 0.75f32,
282 },
283 location_predicate: StructureRuleTestData::AlwaysTrue,
284 position_predicate: PosRuleTestData::AlwaysTrue,
285 output_state: BlockStateData {
286 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
287 properties: std::collections::BTreeMap::new(),
288 },
289 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
290 },
291 ProcessorRuleData {
292 input_predicate: StructureRuleTestData::RandomBlockMatch {
293 block: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
294 probability: 0.15f32,
295 },
296 location_predicate: StructureRuleTestData::AlwaysTrue,
297 position_predicate: PosRuleTestData::AlwaysTrue,
298 output_state: BlockStateData {
299 name: Identifier::vanilla_static("polished_blackstone_bricks"),
300 properties: std::collections::BTreeMap::new(),
301 },
302 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
303 },
304 ProcessorRuleData {
305 input_predicate: StructureRuleTestData::RandomBlockMatch {
306 block: Identifier::vanilla_static("gilded_blackstone"),
307 probability: 0.5f32,
308 },
309 location_predicate: StructureRuleTestData::AlwaysTrue,
310 position_predicate: PosRuleTestData::AlwaysTrue,
311 output_state: BlockStateData {
312 name: Identifier::vanilla_static("blackstone"),
313 properties: std::collections::BTreeMap::new(),
314 },
315 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
316 },
317 ProcessorRuleData {
318 input_predicate: StructureRuleTestData::RandomBlockMatch {
319 block: Identifier::vanilla_static("blackstone"),
320 probability: 0.01f32,
321 },
322 location_predicate: StructureRuleTestData::AlwaysTrue,
323 position_predicate: PosRuleTestData::AlwaysTrue,
324 output_state: BlockStateData {
325 name: Identifier::vanilla_static("gilded_blackstone"),
326 properties: std::collections::BTreeMap::new(),
327 },
328 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
329 },
330 ],
331 }],
332 },
333 id: OnceLock::new(),
334 });
335pub static BRIDGE: LazyLock<StructureProcessorList> = LazyLock::new(|| StructureProcessorList {
336 key: Identifier::vanilla_static("bridge"),
337 data: StructureProcessorListData {
338 processors: vec![StructureProcessorKind::Rule {
339 rules: vec![
340 ProcessorRuleData {
341 input_predicate: StructureRuleTestData::RandomBlockMatch {
342 block: Identifier::vanilla_static("polished_blackstone_bricks"),
343 probability: 0.3f32,
344 },
345 location_predicate: StructureRuleTestData::AlwaysTrue,
346 position_predicate: PosRuleTestData::AlwaysTrue,
347 output_state: BlockStateData {
348 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
349 properties: std::collections::BTreeMap::new(),
350 },
351 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
352 },
353 ProcessorRuleData {
354 input_predicate: StructureRuleTestData::RandomBlockMatch {
355 block: Identifier::vanilla_static("blackstone"),
356 probability: 0.0001f32,
357 },
358 location_predicate: StructureRuleTestData::AlwaysTrue,
359 position_predicate: PosRuleTestData::AlwaysTrue,
360 output_state: BlockStateData {
361 name: Identifier::vanilla_static("air"),
362 properties: std::collections::BTreeMap::new(),
363 },
364 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
365 },
366 ],
367 }],
368 },
369 id: OnceLock::new(),
370});
371pub static EMPTY: LazyLock<StructureProcessorList> = LazyLock::new(|| StructureProcessorList {
372 key: Identifier::vanilla_static("empty"),
373 data: StructureProcessorListData { processors: vec![] },
374 id: OnceLock::new(),
375});
376pub static ENTRANCE_REPLACEMENT: LazyLock<StructureProcessorList> =
377 LazyLock::new(|| StructureProcessorList {
378 key: Identifier::vanilla_static("entrance_replacement"),
379 data: StructureProcessorListData {
380 processors: vec![StructureProcessorKind::Rule {
381 rules: vec![
382 ProcessorRuleData {
383 input_predicate: StructureRuleTestData::RandomBlockMatch {
384 block: Identifier::vanilla_static("chiseled_polished_blackstone"),
385 probability: 0.5f32,
386 },
387 location_predicate: StructureRuleTestData::AlwaysTrue,
388 position_predicate: PosRuleTestData::AlwaysTrue,
389 output_state: BlockStateData {
390 name: Identifier::vanilla_static("air"),
391 properties: std::collections::BTreeMap::new(),
392 },
393 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
394 },
395 ProcessorRuleData {
396 input_predicate: StructureRuleTestData::RandomBlockMatch {
397 block: Identifier::vanilla_static("gold_block"),
398 probability: 0.6f32,
399 },
400 location_predicate: StructureRuleTestData::AlwaysTrue,
401 position_predicate: PosRuleTestData::AlwaysTrue,
402 output_state: BlockStateData {
403 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
404 properties: std::collections::BTreeMap::new(),
405 },
406 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
407 },
408 ProcessorRuleData {
409 input_predicate: StructureRuleTestData::RandomBlockMatch {
410 block: Identifier::vanilla_static("gilded_blackstone"),
411 probability: 0.5f32,
412 },
413 location_predicate: StructureRuleTestData::AlwaysTrue,
414 position_predicate: PosRuleTestData::AlwaysTrue,
415 output_state: BlockStateData {
416 name: Identifier::vanilla_static("blackstone"),
417 properties: std::collections::BTreeMap::new(),
418 },
419 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
420 },
421 ProcessorRuleData {
422 input_predicate: StructureRuleTestData::RandomBlockMatch {
423 block: Identifier::vanilla_static("blackstone"),
424 probability: 0.01f32,
425 },
426 location_predicate: StructureRuleTestData::AlwaysTrue,
427 position_predicate: PosRuleTestData::AlwaysTrue,
428 output_state: BlockStateData {
429 name: Identifier::vanilla_static("gilded_blackstone"),
430 properties: std::collections::BTreeMap::new(),
431 },
432 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
433 },
434 ],
435 }],
436 },
437 id: OnceLock::new(),
438 });
439pub static FARM_DESERT: LazyLock<StructureProcessorList> =
440 LazyLock::new(|| StructureProcessorList {
441 key: Identifier::vanilla_static("farm_desert"),
442 data: StructureProcessorListData {
443 processors: vec![StructureProcessorKind::Rule {
444 rules: vec![
445 ProcessorRuleData {
446 input_predicate: StructureRuleTestData::RandomBlockMatch {
447 block: Identifier::vanilla_static("wheat"),
448 probability: 0.2f32,
449 },
450 location_predicate: StructureRuleTestData::AlwaysTrue,
451 position_predicate: PosRuleTestData::AlwaysTrue,
452 output_state: BlockStateData {
453 name: Identifier::vanilla_static("beetroots"),
454 properties: std::collections::BTreeMap::from([(
455 "age".to_owned(),
456 "0".to_owned(),
457 )]),
458 },
459 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
460 },
461 ProcessorRuleData {
462 input_predicate: StructureRuleTestData::RandomBlockMatch {
463 block: Identifier::vanilla_static("wheat"),
464 probability: 0.1f32,
465 },
466 location_predicate: StructureRuleTestData::AlwaysTrue,
467 position_predicate: PosRuleTestData::AlwaysTrue,
468 output_state: BlockStateData {
469 name: Identifier::vanilla_static("melon_stem"),
470 properties: std::collections::BTreeMap::from([(
471 "age".to_owned(),
472 "0".to_owned(),
473 )]),
474 },
475 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
476 },
477 ],
478 }],
479 },
480 id: OnceLock::new(),
481 });
482pub static FARM_PLAINS: LazyLock<StructureProcessorList> =
483 LazyLock::new(|| StructureProcessorList {
484 key: Identifier::vanilla_static("farm_plains"),
485 data: StructureProcessorListData {
486 processors: vec![StructureProcessorKind::Rule {
487 rules: vec![
488 ProcessorRuleData {
489 input_predicate: StructureRuleTestData::RandomBlockMatch {
490 block: Identifier::vanilla_static("wheat"),
491 probability: 0.3f32,
492 },
493 location_predicate: StructureRuleTestData::AlwaysTrue,
494 position_predicate: PosRuleTestData::AlwaysTrue,
495 output_state: BlockStateData {
496 name: Identifier::vanilla_static("carrots"),
497 properties: std::collections::BTreeMap::from([(
498 "age".to_owned(),
499 "0".to_owned(),
500 )]),
501 },
502 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
503 },
504 ProcessorRuleData {
505 input_predicate: StructureRuleTestData::RandomBlockMatch {
506 block: Identifier::vanilla_static("wheat"),
507 probability: 0.2f32,
508 },
509 location_predicate: StructureRuleTestData::AlwaysTrue,
510 position_predicate: PosRuleTestData::AlwaysTrue,
511 output_state: BlockStateData {
512 name: Identifier::vanilla_static("potatoes"),
513 properties: std::collections::BTreeMap::from([(
514 "age".to_owned(),
515 "0".to_owned(),
516 )]),
517 },
518 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
519 },
520 ProcessorRuleData {
521 input_predicate: StructureRuleTestData::RandomBlockMatch {
522 block: Identifier::vanilla_static("wheat"),
523 probability: 0.1f32,
524 },
525 location_predicate: StructureRuleTestData::AlwaysTrue,
526 position_predicate: PosRuleTestData::AlwaysTrue,
527 output_state: BlockStateData {
528 name: Identifier::vanilla_static("beetroots"),
529 properties: std::collections::BTreeMap::from([(
530 "age".to_owned(),
531 "0".to_owned(),
532 )]),
533 },
534 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
535 },
536 ],
537 }],
538 },
539 id: OnceLock::new(),
540 });
541pub static FARM_SAVANNA: LazyLock<StructureProcessorList> =
542 LazyLock::new(|| StructureProcessorList {
543 key: Identifier::vanilla_static("farm_savanna"),
544 data: StructureProcessorListData {
545 processors: vec![StructureProcessorKind::Rule {
546 rules: vec![ProcessorRuleData {
547 input_predicate: StructureRuleTestData::RandomBlockMatch {
548 block: Identifier::vanilla_static("wheat"),
549 probability: 0.1f32,
550 },
551 location_predicate: StructureRuleTestData::AlwaysTrue,
552 position_predicate: PosRuleTestData::AlwaysTrue,
553 output_state: BlockStateData {
554 name: Identifier::vanilla_static("melon_stem"),
555 properties: std::collections::BTreeMap::from([(
556 "age".to_owned(),
557 "0".to_owned(),
558 )]),
559 },
560 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
561 }],
562 }],
563 },
564 id: OnceLock::new(),
565 });
566pub static FARM_SNOWY: LazyLock<StructureProcessorList> =
567 LazyLock::new(|| StructureProcessorList {
568 key: Identifier::vanilla_static("farm_snowy"),
569 data: StructureProcessorListData {
570 processors: vec![StructureProcessorKind::Rule {
571 rules: vec![
572 ProcessorRuleData {
573 input_predicate: StructureRuleTestData::RandomBlockMatch {
574 block: Identifier::vanilla_static("wheat"),
575 probability: 0.1f32,
576 },
577 location_predicate: StructureRuleTestData::AlwaysTrue,
578 position_predicate: PosRuleTestData::AlwaysTrue,
579 output_state: BlockStateData {
580 name: Identifier::vanilla_static("carrots"),
581 properties: std::collections::BTreeMap::from([(
582 "age".to_owned(),
583 "0".to_owned(),
584 )]),
585 },
586 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
587 },
588 ProcessorRuleData {
589 input_predicate: StructureRuleTestData::RandomBlockMatch {
590 block: Identifier::vanilla_static("wheat"),
591 probability: 0.8f32,
592 },
593 location_predicate: StructureRuleTestData::AlwaysTrue,
594 position_predicate: PosRuleTestData::AlwaysTrue,
595 output_state: BlockStateData {
596 name: Identifier::vanilla_static("potatoes"),
597 properties: std::collections::BTreeMap::from([(
598 "age".to_owned(),
599 "0".to_owned(),
600 )]),
601 },
602 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
603 },
604 ],
605 }],
606 },
607 id: OnceLock::new(),
608 });
609pub static FARM_TAIGA: LazyLock<StructureProcessorList> =
610 LazyLock::new(|| StructureProcessorList {
611 key: Identifier::vanilla_static("farm_taiga"),
612 data: StructureProcessorListData {
613 processors: vec![StructureProcessorKind::Rule {
614 rules: vec![
615 ProcessorRuleData {
616 input_predicate: StructureRuleTestData::RandomBlockMatch {
617 block: Identifier::vanilla_static("wheat"),
618 probability: 0.3f32,
619 },
620 location_predicate: StructureRuleTestData::AlwaysTrue,
621 position_predicate: PosRuleTestData::AlwaysTrue,
622 output_state: BlockStateData {
623 name: Identifier::vanilla_static("pumpkin_stem"),
624 properties: std::collections::BTreeMap::from([(
625 "age".to_owned(),
626 "0".to_owned(),
627 )]),
628 },
629 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
630 },
631 ProcessorRuleData {
632 input_predicate: StructureRuleTestData::RandomBlockMatch {
633 block: Identifier::vanilla_static("wheat"),
634 probability: 0.2f32,
635 },
636 location_predicate: StructureRuleTestData::AlwaysTrue,
637 position_predicate: PosRuleTestData::AlwaysTrue,
638 output_state: BlockStateData {
639 name: Identifier::vanilla_static("potatoes"),
640 properties: std::collections::BTreeMap::from([(
641 "age".to_owned(),
642 "0".to_owned(),
643 )]),
644 },
645 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
646 },
647 ],
648 }],
649 },
650 id: OnceLock::new(),
651 });
652pub static FOSSIL_COAL: LazyLock<StructureProcessorList> =
653 LazyLock::new(|| StructureProcessorList {
654 key: Identifier::vanilla_static("fossil_coal"),
655 data: StructureProcessorListData {
656 processors: vec![
657 StructureProcessorKind::BlockRot {
658 rottable_blocks: None,
659 integrity: 0.1f32,
660 },
661 StructureProcessorKind::ProtectedBlocks {
662 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
663 },
664 ],
665 },
666 id: OnceLock::new(),
667 });
668pub static FOSSIL_DIAMONDS: LazyLock<StructureProcessorList> =
669 LazyLock::new(|| StructureProcessorList {
670 key: Identifier::vanilla_static("fossil_diamonds"),
671 data: StructureProcessorListData {
672 processors: vec![
673 StructureProcessorKind::BlockRot {
674 rottable_blocks: None,
675 integrity: 0.1f32,
676 },
677 StructureProcessorKind::Rule {
678 rules: vec![ProcessorRuleData {
679 input_predicate: StructureRuleTestData::BlockMatch {
680 block: Identifier::vanilla_static("coal_ore"),
681 },
682 location_predicate: StructureRuleTestData::AlwaysTrue,
683 position_predicate: PosRuleTestData::AlwaysTrue,
684 output_state: BlockStateData {
685 name: Identifier::vanilla_static("deepslate_diamond_ore"),
686 properties: std::collections::BTreeMap::new(),
687 },
688 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
689 }],
690 },
691 StructureProcessorKind::ProtectedBlocks {
692 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
693 },
694 ],
695 },
696 id: OnceLock::new(),
697 });
698pub static FOSSIL_ROT: LazyLock<StructureProcessorList> =
699 LazyLock::new(|| StructureProcessorList {
700 key: Identifier::vanilla_static("fossil_rot"),
701 data: StructureProcessorListData {
702 processors: vec![
703 StructureProcessorKind::BlockRot {
704 rottable_blocks: None,
705 integrity: 0.9f32,
706 },
707 StructureProcessorKind::ProtectedBlocks {
708 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
709 },
710 ],
711 },
712 id: OnceLock::new(),
713 });
714pub static HIGH_RAMPART: LazyLock<StructureProcessorList> =
715 LazyLock::new(|| StructureProcessorList {
716 key: Identifier::vanilla_static("high_rampart"),
717 data: StructureProcessorListData {
718 processors: vec![StructureProcessorKind::Rule {
719 rules: vec![
720 ProcessorRuleData {
721 input_predicate: StructureRuleTestData::RandomBlockMatch {
722 block: Identifier::vanilla_static("gold_block"),
723 probability: 0.3f32,
724 },
725 location_predicate: StructureRuleTestData::AlwaysTrue,
726 position_predicate: PosRuleTestData::AlwaysTrue,
727 output_state: BlockStateData {
728 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
729 properties: std::collections::BTreeMap::new(),
730 },
731 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
732 },
733 ProcessorRuleData {
734 input_predicate: StructureRuleTestData::AlwaysTrue,
735 location_predicate: StructureRuleTestData::AlwaysTrue,
736 position_predicate: PosRuleTestData::AxisAlignedLinearPos {
737 axis: StructureProcessorAxis::Y,
738 min_chance: 0f32,
739 max_chance: 0.05f32,
740 min_dist: 0i32,
741 max_dist: 100i32,
742 },
743 output_state: BlockStateData {
744 name: Identifier::vanilla_static("air"),
745 properties: std::collections::BTreeMap::new(),
746 },
747 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
748 },
749 ProcessorRuleData {
750 input_predicate: StructureRuleTestData::RandomBlockMatch {
751 block: Identifier::vanilla_static("gilded_blackstone"),
752 probability: 0.5f32,
753 },
754 location_predicate: StructureRuleTestData::AlwaysTrue,
755 position_predicate: PosRuleTestData::AlwaysTrue,
756 output_state: BlockStateData {
757 name: Identifier::vanilla_static("blackstone"),
758 properties: std::collections::BTreeMap::new(),
759 },
760 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
761 },
762 ],
763 }],
764 },
765 id: OnceLock::new(),
766 });
767pub static HIGH_WALL: LazyLock<StructureProcessorList> = LazyLock::new(|| StructureProcessorList {
768 key: Identifier::vanilla_static("high_wall"),
769 data: StructureProcessorListData {
770 processors: vec![StructureProcessorKind::Rule {
771 rules: vec![
772 ProcessorRuleData {
773 input_predicate: StructureRuleTestData::RandomBlockMatch {
774 block: Identifier::vanilla_static("polished_blackstone_bricks"),
775 probability: 0.01f32,
776 },
777 location_predicate: StructureRuleTestData::AlwaysTrue,
778 position_predicate: PosRuleTestData::AlwaysTrue,
779 output_state: BlockStateData {
780 name: Identifier::vanilla_static("air"),
781 properties: std::collections::BTreeMap::new(),
782 },
783 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
784 },
785 ProcessorRuleData {
786 input_predicate: StructureRuleTestData::RandomBlockMatch {
787 block: Identifier::vanilla_static("polished_blackstone_bricks"),
788 probability: 0.5f32,
789 },
790 location_predicate: StructureRuleTestData::AlwaysTrue,
791 position_predicate: PosRuleTestData::AlwaysTrue,
792 output_state: BlockStateData {
793 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
794 properties: std::collections::BTreeMap::new(),
795 },
796 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
797 },
798 ProcessorRuleData {
799 input_predicate: StructureRuleTestData::RandomBlockMatch {
800 block: Identifier::vanilla_static("polished_blackstone_bricks"),
801 probability: 0.3f32,
802 },
803 location_predicate: StructureRuleTestData::AlwaysTrue,
804 position_predicate: PosRuleTestData::AlwaysTrue,
805 output_state: BlockStateData {
806 name: Identifier::vanilla_static("blackstone"),
807 properties: std::collections::BTreeMap::new(),
808 },
809 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
810 },
811 ProcessorRuleData {
812 input_predicate: StructureRuleTestData::RandomBlockMatch {
813 block: Identifier::vanilla_static("gilded_blackstone"),
814 probability: 0.5f32,
815 },
816 location_predicate: StructureRuleTestData::AlwaysTrue,
817 position_predicate: PosRuleTestData::AlwaysTrue,
818 output_state: BlockStateData {
819 name: Identifier::vanilla_static("blackstone"),
820 properties: std::collections::BTreeMap::new(),
821 },
822 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
823 },
824 ],
825 }],
826 },
827 id: OnceLock::new(),
828});
829pub static HOUSING: LazyLock<StructureProcessorList> = LazyLock::new(|| StructureProcessorList {
830 key: Identifier::vanilla_static("housing"),
831 data: StructureProcessorListData {
832 processors: vec![StructureProcessorKind::Rule {
833 rules: vec![
834 ProcessorRuleData {
835 input_predicate: StructureRuleTestData::RandomBlockMatch {
836 block: Identifier::vanilla_static("polished_blackstone_bricks"),
837 probability: 0.3f32,
838 },
839 location_predicate: StructureRuleTestData::AlwaysTrue,
840 position_predicate: PosRuleTestData::AlwaysTrue,
841 output_state: BlockStateData {
842 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
843 properties: std::collections::BTreeMap::new(),
844 },
845 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
846 },
847 ProcessorRuleData {
848 input_predicate: StructureRuleTestData::RandomBlockMatch {
849 block: Identifier::vanilla_static("blackstone"),
850 probability: 0.0001f32,
851 },
852 location_predicate: StructureRuleTestData::AlwaysTrue,
853 position_predicate: PosRuleTestData::AlwaysTrue,
854 output_state: BlockStateData {
855 name: Identifier::vanilla_static("air"),
856 properties: std::collections::BTreeMap::new(),
857 },
858 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
859 },
860 ProcessorRuleData {
861 input_predicate: StructureRuleTestData::RandomBlockMatch {
862 block: Identifier::vanilla_static("gilded_blackstone"),
863 probability: 0.5f32,
864 },
865 location_predicate: StructureRuleTestData::AlwaysTrue,
866 position_predicate: PosRuleTestData::AlwaysTrue,
867 output_state: BlockStateData {
868 name: Identifier::vanilla_static("blackstone"),
869 properties: std::collections::BTreeMap::new(),
870 },
871 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
872 },
873 ProcessorRuleData {
874 input_predicate: StructureRuleTestData::RandomBlockMatch {
875 block: Identifier::vanilla_static("blackstone"),
876 probability: 0.01f32,
877 },
878 location_predicate: StructureRuleTestData::AlwaysTrue,
879 position_predicate: PosRuleTestData::AlwaysTrue,
880 output_state: BlockStateData {
881 name: Identifier::vanilla_static("gilded_blackstone"),
882 properties: std::collections::BTreeMap::new(),
883 },
884 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
885 },
886 ],
887 }],
888 },
889 id: OnceLock::new(),
890});
891pub static MOSSIFY_10_PERCENT: LazyLock<StructureProcessorList> =
892 LazyLock::new(|| StructureProcessorList {
893 key: Identifier::vanilla_static("mossify_10_percent"),
894 data: StructureProcessorListData {
895 processors: vec![StructureProcessorKind::Rule {
896 rules: vec![ProcessorRuleData {
897 input_predicate: StructureRuleTestData::RandomBlockMatch {
898 block: Identifier::vanilla_static("cobblestone"),
899 probability: 0.1f32,
900 },
901 location_predicate: StructureRuleTestData::AlwaysTrue,
902 position_predicate: PosRuleTestData::AlwaysTrue,
903 output_state: BlockStateData {
904 name: Identifier::vanilla_static("mossy_cobblestone"),
905 properties: std::collections::BTreeMap::new(),
906 },
907 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
908 }],
909 }],
910 },
911 id: OnceLock::new(),
912 });
913pub static MOSSIFY_20_PERCENT: LazyLock<StructureProcessorList> =
914 LazyLock::new(|| StructureProcessorList {
915 key: Identifier::vanilla_static("mossify_20_percent"),
916 data: StructureProcessorListData {
917 processors: vec![StructureProcessorKind::Rule {
918 rules: vec![ProcessorRuleData {
919 input_predicate: StructureRuleTestData::RandomBlockMatch {
920 block: Identifier::vanilla_static("cobblestone"),
921 probability: 0.2f32,
922 },
923 location_predicate: StructureRuleTestData::AlwaysTrue,
924 position_predicate: PosRuleTestData::AlwaysTrue,
925 output_state: BlockStateData {
926 name: Identifier::vanilla_static("mossy_cobblestone"),
927 properties: std::collections::BTreeMap::new(),
928 },
929 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
930 }],
931 }],
932 },
933 id: OnceLock::new(),
934 });
935pub static MOSSIFY_70_PERCENT: LazyLock<StructureProcessorList> =
936 LazyLock::new(|| StructureProcessorList {
937 key: Identifier::vanilla_static("mossify_70_percent"),
938 data: StructureProcessorListData {
939 processors: vec![StructureProcessorKind::Rule {
940 rules: vec![ProcessorRuleData {
941 input_predicate: StructureRuleTestData::RandomBlockMatch {
942 block: Identifier::vanilla_static("cobblestone"),
943 probability: 0.7f32,
944 },
945 location_predicate: StructureRuleTestData::AlwaysTrue,
946 position_predicate: PosRuleTestData::AlwaysTrue,
947 output_state: BlockStateData {
948 name: Identifier::vanilla_static("mossy_cobblestone"),
949 properties: std::collections::BTreeMap::new(),
950 },
951 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
952 }],
953 }],
954 },
955 id: OnceLock::new(),
956 });
957pub static OUTPOST_ROT: LazyLock<StructureProcessorList> =
958 LazyLock::new(|| StructureProcessorList {
959 key: Identifier::vanilla_static("outpost_rot"),
960 data: StructureProcessorListData {
961 processors: vec![StructureProcessorKind::BlockRot {
962 rottable_blocks: None,
963 integrity: 0.05f32,
964 }],
965 },
966 id: OnceLock::new(),
967 });
968pub static RAMPART_DEGRADATION: LazyLock<StructureProcessorList> =
969 LazyLock::new(|| StructureProcessorList {
970 key: Identifier::vanilla_static("rampart_degradation"),
971 data: StructureProcessorListData {
972 processors: vec![StructureProcessorKind::Rule {
973 rules: vec![
974 ProcessorRuleData {
975 input_predicate: StructureRuleTestData::RandomBlockMatch {
976 block: Identifier::vanilla_static("polished_blackstone_bricks"),
977 probability: 0.4f32,
978 },
979 location_predicate: StructureRuleTestData::AlwaysTrue,
980 position_predicate: PosRuleTestData::AlwaysTrue,
981 output_state: BlockStateData {
982 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
983 properties: std::collections::BTreeMap::new(),
984 },
985 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
986 },
987 ProcessorRuleData {
988 input_predicate: StructureRuleTestData::RandomBlockMatch {
989 block: Identifier::vanilla_static("blackstone"),
990 probability: 0.01f32,
991 },
992 location_predicate: StructureRuleTestData::AlwaysTrue,
993 position_predicate: PosRuleTestData::AlwaysTrue,
994 output_state: BlockStateData {
995 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
996 properties: std::collections::BTreeMap::new(),
997 },
998 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
999 },
1000 ProcessorRuleData {
1001 input_predicate: StructureRuleTestData::RandomBlockMatch {
1002 block: Identifier::vanilla_static("polished_blackstone_bricks"),
1003 probability: 0.0001f32,
1004 },
1005 location_predicate: StructureRuleTestData::AlwaysTrue,
1006 position_predicate: PosRuleTestData::AlwaysTrue,
1007 output_state: BlockStateData {
1008 name: Identifier::vanilla_static("air"),
1009 properties: std::collections::BTreeMap::new(),
1010 },
1011 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1012 },
1013 ProcessorRuleData {
1014 input_predicate: StructureRuleTestData::RandomBlockMatch {
1015 block: Identifier::vanilla_static("blackstone"),
1016 probability: 0.0001f32,
1017 },
1018 location_predicate: StructureRuleTestData::AlwaysTrue,
1019 position_predicate: PosRuleTestData::AlwaysTrue,
1020 output_state: BlockStateData {
1021 name: Identifier::vanilla_static("air"),
1022 properties: std::collections::BTreeMap::new(),
1023 },
1024 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1025 },
1026 ProcessorRuleData {
1027 input_predicate: StructureRuleTestData::RandomBlockMatch {
1028 block: Identifier::vanilla_static("gold_block"),
1029 probability: 0.3f32,
1030 },
1031 location_predicate: StructureRuleTestData::AlwaysTrue,
1032 position_predicate: PosRuleTestData::AlwaysTrue,
1033 output_state: BlockStateData {
1034 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
1035 properties: std::collections::BTreeMap::new(),
1036 },
1037 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1038 },
1039 ProcessorRuleData {
1040 input_predicate: StructureRuleTestData::RandomBlockMatch {
1041 block: Identifier::vanilla_static("gilded_blackstone"),
1042 probability: 0.5f32,
1043 },
1044 location_predicate: StructureRuleTestData::AlwaysTrue,
1045 position_predicate: PosRuleTestData::AlwaysTrue,
1046 output_state: BlockStateData {
1047 name: Identifier::vanilla_static("blackstone"),
1048 properties: std::collections::BTreeMap::new(),
1049 },
1050 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1051 },
1052 ProcessorRuleData {
1053 input_predicate: StructureRuleTestData::RandomBlockMatch {
1054 block: Identifier::vanilla_static("blackstone"),
1055 probability: 0.01f32,
1056 },
1057 location_predicate: StructureRuleTestData::AlwaysTrue,
1058 position_predicate: PosRuleTestData::AlwaysTrue,
1059 output_state: BlockStateData {
1060 name: Identifier::vanilla_static("gilded_blackstone"),
1061 properties: std::collections::BTreeMap::new(),
1062 },
1063 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1064 },
1065 ],
1066 }],
1067 },
1068 id: OnceLock::new(),
1069 });
1070pub static ROOF: LazyLock<StructureProcessorList> = LazyLock::new(|| StructureProcessorList {
1071 key: Identifier::vanilla_static("roof"),
1072 data: StructureProcessorListData {
1073 processors: vec![StructureProcessorKind::Rule {
1074 rules: vec![
1075 ProcessorRuleData {
1076 input_predicate: StructureRuleTestData::RandomBlockMatch {
1077 block: Identifier::vanilla_static("polished_blackstone_bricks"),
1078 probability: 0.3f32,
1079 },
1080 location_predicate: StructureRuleTestData::AlwaysTrue,
1081 position_predicate: PosRuleTestData::AlwaysTrue,
1082 output_state: BlockStateData {
1083 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
1084 properties: std::collections::BTreeMap::new(),
1085 },
1086 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1087 },
1088 ProcessorRuleData {
1089 input_predicate: StructureRuleTestData::RandomBlockMatch {
1090 block: Identifier::vanilla_static("polished_blackstone_bricks"),
1091 probability: 0.15f32,
1092 },
1093 location_predicate: StructureRuleTestData::AlwaysTrue,
1094 position_predicate: PosRuleTestData::AlwaysTrue,
1095 output_state: BlockStateData {
1096 name: Identifier::vanilla_static("air"),
1097 properties: std::collections::BTreeMap::new(),
1098 },
1099 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1100 },
1101 ProcessorRuleData {
1102 input_predicate: StructureRuleTestData::RandomBlockMatch {
1103 block: Identifier::vanilla_static("polished_blackstone_bricks"),
1104 probability: 0.3f32,
1105 },
1106 location_predicate: StructureRuleTestData::AlwaysTrue,
1107 position_predicate: PosRuleTestData::AlwaysTrue,
1108 output_state: BlockStateData {
1109 name: Identifier::vanilla_static("blackstone"),
1110 properties: std::collections::BTreeMap::new(),
1111 },
1112 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1113 },
1114 ],
1115 }],
1116 },
1117 id: OnceLock::new(),
1118});
1119pub static SIDE_WALL_DEGRADATION: LazyLock<StructureProcessorList> =
1120 LazyLock::new(|| StructureProcessorList {
1121 key: Identifier::vanilla_static("side_wall_degradation"),
1122 data: StructureProcessorListData {
1123 processors: vec![StructureProcessorKind::Rule {
1124 rules: vec![
1125 ProcessorRuleData {
1126 input_predicate: StructureRuleTestData::RandomBlockMatch {
1127 block: Identifier::vanilla_static("chiseled_polished_blackstone"),
1128 probability: 0.5f32,
1129 },
1130 location_predicate: StructureRuleTestData::AlwaysTrue,
1131 position_predicate: PosRuleTestData::AlwaysTrue,
1132 output_state: BlockStateData {
1133 name: Identifier::vanilla_static("air"),
1134 properties: std::collections::BTreeMap::new(),
1135 },
1136 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1137 },
1138 ProcessorRuleData {
1139 input_predicate: StructureRuleTestData::RandomBlockMatch {
1140 block: Identifier::vanilla_static("gold_block"),
1141 probability: 0.1f32,
1142 },
1143 location_predicate: StructureRuleTestData::AlwaysTrue,
1144 position_predicate: PosRuleTestData::AlwaysTrue,
1145 output_state: BlockStateData {
1146 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
1147 properties: std::collections::BTreeMap::new(),
1148 },
1149 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1150 },
1151 ProcessorRuleData {
1152 input_predicate: StructureRuleTestData::RandomBlockMatch {
1153 block: Identifier::vanilla_static("gilded_blackstone"),
1154 probability: 0.5f32,
1155 },
1156 location_predicate: StructureRuleTestData::AlwaysTrue,
1157 position_predicate: PosRuleTestData::AlwaysTrue,
1158 output_state: BlockStateData {
1159 name: Identifier::vanilla_static("blackstone"),
1160 properties: std::collections::BTreeMap::new(),
1161 },
1162 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1163 },
1164 ProcessorRuleData {
1165 input_predicate: StructureRuleTestData::RandomBlockMatch {
1166 block: Identifier::vanilla_static("blackstone"),
1167 probability: 0.01f32,
1168 },
1169 location_predicate: StructureRuleTestData::AlwaysTrue,
1170 position_predicate: PosRuleTestData::AlwaysTrue,
1171 output_state: BlockStateData {
1172 name: Identifier::vanilla_static("gilded_blackstone"),
1173 properties: std::collections::BTreeMap::new(),
1174 },
1175 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1176 },
1177 ],
1178 }],
1179 },
1180 id: OnceLock::new(),
1181 });
1182pub static STABLE_DEGRADATION: LazyLock<StructureProcessorList> =
1183 LazyLock::new(|| StructureProcessorList {
1184 key: Identifier::vanilla_static("stable_degradation"),
1185 data: StructureProcessorListData {
1186 processors: vec![StructureProcessorKind::Rule {
1187 rules: vec![
1188 ProcessorRuleData {
1189 input_predicate: StructureRuleTestData::RandomBlockMatch {
1190 block: Identifier::vanilla_static("polished_blackstone_bricks"),
1191 probability: 0.1f32,
1192 },
1193 location_predicate: StructureRuleTestData::AlwaysTrue,
1194 position_predicate: PosRuleTestData::AlwaysTrue,
1195 output_state: BlockStateData {
1196 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
1197 properties: std::collections::BTreeMap::new(),
1198 },
1199 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1200 },
1201 ProcessorRuleData {
1202 input_predicate: StructureRuleTestData::RandomBlockMatch {
1203 block: Identifier::vanilla_static("blackstone"),
1204 probability: 0.0001f32,
1205 },
1206 location_predicate: StructureRuleTestData::AlwaysTrue,
1207 position_predicate: PosRuleTestData::AlwaysTrue,
1208 output_state: BlockStateData {
1209 name: Identifier::vanilla_static("air"),
1210 properties: std::collections::BTreeMap::new(),
1211 },
1212 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1213 },
1214 ProcessorRuleData {
1215 input_predicate: StructureRuleTestData::RandomBlockMatch {
1216 block: Identifier::vanilla_static("gilded_blackstone"),
1217 probability: 0.5f32,
1218 },
1219 location_predicate: StructureRuleTestData::AlwaysTrue,
1220 position_predicate: PosRuleTestData::AlwaysTrue,
1221 output_state: BlockStateData {
1222 name: Identifier::vanilla_static("blackstone"),
1223 properties: std::collections::BTreeMap::new(),
1224 },
1225 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1226 },
1227 ProcessorRuleData {
1228 input_predicate: StructureRuleTestData::RandomBlockMatch {
1229 block: Identifier::vanilla_static("blackstone"),
1230 probability: 0.01f32,
1231 },
1232 location_predicate: StructureRuleTestData::AlwaysTrue,
1233 position_predicate: PosRuleTestData::AlwaysTrue,
1234 output_state: BlockStateData {
1235 name: Identifier::vanilla_static("gilded_blackstone"),
1236 properties: std::collections::BTreeMap::new(),
1237 },
1238 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1239 },
1240 ],
1241 }],
1242 },
1243 id: OnceLock::new(),
1244 });
1245pub static STREET_PLAINS: LazyLock<StructureProcessorList> =
1246 LazyLock::new(|| StructureProcessorList {
1247 key: Identifier::vanilla_static("street_plains"),
1248 data: StructureProcessorListData {
1249 processors: vec![StructureProcessorKind::Rule {
1250 rules: vec![
1251 ProcessorRuleData {
1252 input_predicate: StructureRuleTestData::BlockMatch {
1253 block: Identifier::vanilla_static("dirt_path"),
1254 },
1255 location_predicate: StructureRuleTestData::BlockMatch {
1256 block: Identifier::vanilla_static("water"),
1257 },
1258 position_predicate: PosRuleTestData::AlwaysTrue,
1259 output_state: BlockStateData {
1260 name: Identifier::vanilla_static("oak_planks"),
1261 properties: std::collections::BTreeMap::new(),
1262 },
1263 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1264 },
1265 ProcessorRuleData {
1266 input_predicate: StructureRuleTestData::RandomBlockMatch {
1267 block: Identifier::vanilla_static("dirt_path"),
1268 probability: 0.1f32,
1269 },
1270 location_predicate: StructureRuleTestData::AlwaysTrue,
1271 position_predicate: PosRuleTestData::AlwaysTrue,
1272 output_state: BlockStateData {
1273 name: Identifier::vanilla_static("grass_block"),
1274 properties: std::collections::BTreeMap::from([(
1275 "snowy".to_owned(),
1276 "false".to_owned(),
1277 )]),
1278 },
1279 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1280 },
1281 ProcessorRuleData {
1282 input_predicate: StructureRuleTestData::BlockMatch {
1283 block: Identifier::vanilla_static("grass_block"),
1284 },
1285 location_predicate: StructureRuleTestData::BlockMatch {
1286 block: Identifier::vanilla_static("water"),
1287 },
1288 position_predicate: PosRuleTestData::AlwaysTrue,
1289 output_state: BlockStateData {
1290 name: Identifier::vanilla_static("water"),
1291 properties: std::collections::BTreeMap::from([(
1292 "level".to_owned(),
1293 "0".to_owned(),
1294 )]),
1295 },
1296 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1297 },
1298 ProcessorRuleData {
1299 input_predicate: StructureRuleTestData::BlockMatch {
1300 block: Identifier::vanilla_static("dirt"),
1301 },
1302 location_predicate: StructureRuleTestData::BlockMatch {
1303 block: Identifier::vanilla_static("water"),
1304 },
1305 position_predicate: PosRuleTestData::AlwaysTrue,
1306 output_state: BlockStateData {
1307 name: Identifier::vanilla_static("water"),
1308 properties: std::collections::BTreeMap::from([(
1309 "level".to_owned(),
1310 "0".to_owned(),
1311 )]),
1312 },
1313 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1314 },
1315 ],
1316 }],
1317 },
1318 id: OnceLock::new(),
1319 });
1320pub static STREET_SAVANNA: LazyLock<StructureProcessorList> =
1321 LazyLock::new(|| StructureProcessorList {
1322 key: Identifier::vanilla_static("street_savanna"),
1323 data: StructureProcessorListData {
1324 processors: vec![StructureProcessorKind::Rule {
1325 rules: vec![
1326 ProcessorRuleData {
1327 input_predicate: StructureRuleTestData::BlockMatch {
1328 block: Identifier::vanilla_static("dirt_path"),
1329 },
1330 location_predicate: StructureRuleTestData::BlockMatch {
1331 block: Identifier::vanilla_static("water"),
1332 },
1333 position_predicate: PosRuleTestData::AlwaysTrue,
1334 output_state: BlockStateData {
1335 name: Identifier::vanilla_static("acacia_planks"),
1336 properties: std::collections::BTreeMap::new(),
1337 },
1338 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1339 },
1340 ProcessorRuleData {
1341 input_predicate: StructureRuleTestData::RandomBlockMatch {
1342 block: Identifier::vanilla_static("dirt_path"),
1343 probability: 0.2f32,
1344 },
1345 location_predicate: StructureRuleTestData::AlwaysTrue,
1346 position_predicate: PosRuleTestData::AlwaysTrue,
1347 output_state: BlockStateData {
1348 name: Identifier::vanilla_static("grass_block"),
1349 properties: std::collections::BTreeMap::from([(
1350 "snowy".to_owned(),
1351 "false".to_owned(),
1352 )]),
1353 },
1354 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1355 },
1356 ProcessorRuleData {
1357 input_predicate: StructureRuleTestData::BlockMatch {
1358 block: Identifier::vanilla_static("grass_block"),
1359 },
1360 location_predicate: StructureRuleTestData::BlockMatch {
1361 block: Identifier::vanilla_static("water"),
1362 },
1363 position_predicate: PosRuleTestData::AlwaysTrue,
1364 output_state: BlockStateData {
1365 name: Identifier::vanilla_static("water"),
1366 properties: std::collections::BTreeMap::from([(
1367 "level".to_owned(),
1368 "0".to_owned(),
1369 )]),
1370 },
1371 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1372 },
1373 ProcessorRuleData {
1374 input_predicate: StructureRuleTestData::BlockMatch {
1375 block: Identifier::vanilla_static("dirt"),
1376 },
1377 location_predicate: StructureRuleTestData::BlockMatch {
1378 block: Identifier::vanilla_static("water"),
1379 },
1380 position_predicate: PosRuleTestData::AlwaysTrue,
1381 output_state: BlockStateData {
1382 name: Identifier::vanilla_static("water"),
1383 properties: std::collections::BTreeMap::from([(
1384 "level".to_owned(),
1385 "0".to_owned(),
1386 )]),
1387 },
1388 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1389 },
1390 ],
1391 }],
1392 },
1393 id: OnceLock::new(),
1394 });
1395pub static STREET_SNOWY_OR_TAIGA: LazyLock<StructureProcessorList> =
1396 LazyLock::new(|| StructureProcessorList {
1397 key: Identifier::vanilla_static("street_snowy_or_taiga"),
1398 data: StructureProcessorListData {
1399 processors: vec![StructureProcessorKind::Rule {
1400 rules: vec![
1401 ProcessorRuleData {
1402 input_predicate: StructureRuleTestData::BlockMatch {
1403 block: Identifier::vanilla_static("dirt_path"),
1404 },
1405 location_predicate: StructureRuleTestData::BlockMatch {
1406 block: Identifier::vanilla_static("water"),
1407 },
1408 position_predicate: PosRuleTestData::AlwaysTrue,
1409 output_state: BlockStateData {
1410 name: Identifier::vanilla_static("spruce_planks"),
1411 properties: std::collections::BTreeMap::new(),
1412 },
1413 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1414 },
1415 ProcessorRuleData {
1416 input_predicate: StructureRuleTestData::BlockMatch {
1417 block: Identifier::vanilla_static("dirt_path"),
1418 },
1419 location_predicate: StructureRuleTestData::BlockMatch {
1420 block: Identifier::vanilla_static("ice"),
1421 },
1422 position_predicate: PosRuleTestData::AlwaysTrue,
1423 output_state: BlockStateData {
1424 name: Identifier::vanilla_static("spruce_planks"),
1425 properties: std::collections::BTreeMap::new(),
1426 },
1427 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1428 },
1429 ProcessorRuleData {
1430 input_predicate: StructureRuleTestData::RandomBlockMatch {
1431 block: Identifier::vanilla_static("dirt_path"),
1432 probability: 0.2f32,
1433 },
1434 location_predicate: StructureRuleTestData::AlwaysTrue,
1435 position_predicate: PosRuleTestData::AlwaysTrue,
1436 output_state: BlockStateData {
1437 name: Identifier::vanilla_static("grass_block"),
1438 properties: std::collections::BTreeMap::from([(
1439 "snowy".to_owned(),
1440 "false".to_owned(),
1441 )]),
1442 },
1443 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1444 },
1445 ProcessorRuleData {
1446 input_predicate: StructureRuleTestData::BlockMatch {
1447 block: Identifier::vanilla_static("grass_block"),
1448 },
1449 location_predicate: StructureRuleTestData::BlockMatch {
1450 block: Identifier::vanilla_static("water"),
1451 },
1452 position_predicate: PosRuleTestData::AlwaysTrue,
1453 output_state: BlockStateData {
1454 name: Identifier::vanilla_static("water"),
1455 properties: std::collections::BTreeMap::from([(
1456 "level".to_owned(),
1457 "0".to_owned(),
1458 )]),
1459 },
1460 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1461 },
1462 ProcessorRuleData {
1463 input_predicate: StructureRuleTestData::BlockMatch {
1464 block: Identifier::vanilla_static("dirt"),
1465 },
1466 location_predicate: StructureRuleTestData::BlockMatch {
1467 block: Identifier::vanilla_static("water"),
1468 },
1469 position_predicate: PosRuleTestData::AlwaysTrue,
1470 output_state: BlockStateData {
1471 name: Identifier::vanilla_static("water"),
1472 properties: std::collections::BTreeMap::from([(
1473 "level".to_owned(),
1474 "0".to_owned(),
1475 )]),
1476 },
1477 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1478 },
1479 ],
1480 }],
1481 },
1482 id: OnceLock::new(),
1483 });
1484pub static TRAIL_RUINS_HOUSES_ARCHAEOLOGY: LazyLock<StructureProcessorList> =
1485 LazyLock::new(|| StructureProcessorList {
1486 key: Identifier::vanilla_static("trail_ruins_houses_archaeology"),
1487 data: StructureProcessorListData {
1488 processors: vec![
1489 StructureProcessorKind::Rule {
1490 rules: vec![
1491 ProcessorRuleData {
1492 input_predicate: StructureRuleTestData::RandomBlockMatch {
1493 block: Identifier::vanilla_static("gravel"),
1494 probability: 0.2f32,
1495 },
1496 location_predicate: StructureRuleTestData::AlwaysTrue,
1497 position_predicate: PosRuleTestData::AlwaysTrue,
1498 output_state: BlockStateData {
1499 name: Identifier::vanilla_static("dirt"),
1500 properties: std::collections::BTreeMap::new(),
1501 },
1502 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1503 },
1504 ProcessorRuleData {
1505 input_predicate: StructureRuleTestData::RandomBlockMatch {
1506 block: Identifier::vanilla_static("gravel"),
1507 probability: 0.1f32,
1508 },
1509 location_predicate: StructureRuleTestData::AlwaysTrue,
1510 position_predicate: PosRuleTestData::AlwaysTrue,
1511 output_state: BlockStateData {
1512 name: Identifier::vanilla_static("coarse_dirt"),
1513 properties: std::collections::BTreeMap::new(),
1514 },
1515 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1516 },
1517 ProcessorRuleData {
1518 input_predicate: StructureRuleTestData::RandomBlockMatch {
1519 block: Identifier::vanilla_static("mud_bricks"),
1520 probability: 0.1f32,
1521 },
1522 location_predicate: StructureRuleTestData::AlwaysTrue,
1523 position_predicate: PosRuleTestData::AlwaysTrue,
1524 output_state: BlockStateData {
1525 name: Identifier::vanilla_static("packed_mud"),
1526 properties: std::collections::BTreeMap::new(),
1527 },
1528 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1529 },
1530 ],
1531 },
1532 StructureProcessorKind::Capped {
1533 delegate: Box::new(StructureProcessorKind::Rule {
1534 rules: vec![ProcessorRuleData {
1535 input_predicate: StructureRuleTestData::TagMatch {
1536 tag: Identifier::vanilla_static("trail_ruins_replaceable"),
1537 },
1538 location_predicate: StructureRuleTestData::AlwaysTrue,
1539 position_predicate: PosRuleTestData::AlwaysTrue,
1540 output_state: BlockStateData {
1541 name: Identifier::vanilla_static("suspicious_gravel"),
1542 properties: std::collections::BTreeMap::from([(
1543 "dusted".to_owned(),
1544 "0".to_owned(),
1545 )]),
1546 },
1547 block_entity_modifier: RuleBlockEntityModifierData::AppendLoot {
1548 loot_table: Identifier::vanilla_static(
1549 "archaeology/trail_ruins_common",
1550 ),
1551 },
1552 }],
1553 }),
1554 limit: IntProvider::Constant(6i32),
1555 },
1556 StructureProcessorKind::Capped {
1557 delegate: Box::new(StructureProcessorKind::Rule {
1558 rules: vec![ProcessorRuleData {
1559 input_predicate: StructureRuleTestData::TagMatch {
1560 tag: Identifier::vanilla_static("trail_ruins_replaceable"),
1561 },
1562 location_predicate: StructureRuleTestData::AlwaysTrue,
1563 position_predicate: PosRuleTestData::AlwaysTrue,
1564 output_state: BlockStateData {
1565 name: Identifier::vanilla_static("suspicious_gravel"),
1566 properties: std::collections::BTreeMap::from([(
1567 "dusted".to_owned(),
1568 "0".to_owned(),
1569 )]),
1570 },
1571 block_entity_modifier: RuleBlockEntityModifierData::AppendLoot {
1572 loot_table: Identifier::vanilla_static(
1573 "archaeology/trail_ruins_rare",
1574 ),
1575 },
1576 }],
1577 }),
1578 limit: IntProvider::Constant(3i32),
1579 },
1580 ],
1581 },
1582 id: OnceLock::new(),
1583 });
1584pub static TRAIL_RUINS_ROADS_ARCHAEOLOGY: LazyLock<StructureProcessorList> =
1585 LazyLock::new(|| StructureProcessorList {
1586 key: Identifier::vanilla_static("trail_ruins_roads_archaeology"),
1587 data: StructureProcessorListData {
1588 processors: vec![
1589 StructureProcessorKind::Rule {
1590 rules: vec![
1591 ProcessorRuleData {
1592 input_predicate: StructureRuleTestData::RandomBlockMatch {
1593 block: Identifier::vanilla_static("gravel"),
1594 probability: 0.2f32,
1595 },
1596 location_predicate: StructureRuleTestData::AlwaysTrue,
1597 position_predicate: PosRuleTestData::AlwaysTrue,
1598 output_state: BlockStateData {
1599 name: Identifier::vanilla_static("dirt"),
1600 properties: std::collections::BTreeMap::new(),
1601 },
1602 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1603 },
1604 ProcessorRuleData {
1605 input_predicate: StructureRuleTestData::RandomBlockMatch {
1606 block: Identifier::vanilla_static("gravel"),
1607 probability: 0.1f32,
1608 },
1609 location_predicate: StructureRuleTestData::AlwaysTrue,
1610 position_predicate: PosRuleTestData::AlwaysTrue,
1611 output_state: BlockStateData {
1612 name: Identifier::vanilla_static("coarse_dirt"),
1613 properties: std::collections::BTreeMap::new(),
1614 },
1615 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1616 },
1617 ProcessorRuleData {
1618 input_predicate: StructureRuleTestData::RandomBlockMatch {
1619 block: Identifier::vanilla_static("mud_bricks"),
1620 probability: 0.1f32,
1621 },
1622 location_predicate: StructureRuleTestData::AlwaysTrue,
1623 position_predicate: PosRuleTestData::AlwaysTrue,
1624 output_state: BlockStateData {
1625 name: Identifier::vanilla_static("packed_mud"),
1626 properties: std::collections::BTreeMap::new(),
1627 },
1628 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1629 },
1630 ],
1631 },
1632 StructureProcessorKind::Capped {
1633 delegate: Box::new(StructureProcessorKind::Rule {
1634 rules: vec![ProcessorRuleData {
1635 input_predicate: StructureRuleTestData::TagMatch {
1636 tag: Identifier::vanilla_static("trail_ruins_replaceable"),
1637 },
1638 location_predicate: StructureRuleTestData::AlwaysTrue,
1639 position_predicate: PosRuleTestData::AlwaysTrue,
1640 output_state: BlockStateData {
1641 name: Identifier::vanilla_static("suspicious_gravel"),
1642 properties: std::collections::BTreeMap::from([(
1643 "dusted".to_owned(),
1644 "0".to_owned(),
1645 )]),
1646 },
1647 block_entity_modifier: RuleBlockEntityModifierData::AppendLoot {
1648 loot_table: Identifier::vanilla_static(
1649 "archaeology/trail_ruins_common",
1650 ),
1651 },
1652 }],
1653 }),
1654 limit: IntProvider::Constant(2i32),
1655 },
1656 ],
1657 },
1658 id: OnceLock::new(),
1659 });
1660pub static TRAIL_RUINS_TOWER_TOP_ARCHAEOLOGY: LazyLock<StructureProcessorList> =
1661 LazyLock::new(|| StructureProcessorList {
1662 key: Identifier::vanilla_static("trail_ruins_tower_top_archaeology"),
1663 data: StructureProcessorListData {
1664 processors: vec![StructureProcessorKind::Capped {
1665 delegate: Box::new(StructureProcessorKind::Rule {
1666 rules: vec![ProcessorRuleData {
1667 input_predicate: StructureRuleTestData::TagMatch {
1668 tag: Identifier::vanilla_static("trail_ruins_replaceable"),
1669 },
1670 location_predicate: StructureRuleTestData::AlwaysTrue,
1671 position_predicate: PosRuleTestData::AlwaysTrue,
1672 output_state: BlockStateData {
1673 name: Identifier::vanilla_static("suspicious_gravel"),
1674 properties: std::collections::BTreeMap::from([(
1675 "dusted".to_owned(),
1676 "0".to_owned(),
1677 )]),
1678 },
1679 block_entity_modifier: RuleBlockEntityModifierData::AppendLoot {
1680 loot_table: Identifier::vanilla_static(
1681 "archaeology/trail_ruins_common",
1682 ),
1683 },
1684 }],
1685 }),
1686 limit: IntProvider::Constant(2i32),
1687 }],
1688 },
1689 id: OnceLock::new(),
1690 });
1691pub static TREASURE_ROOMS: LazyLock<StructureProcessorList> =
1692 LazyLock::new(|| StructureProcessorList {
1693 key: Identifier::vanilla_static("treasure_rooms"),
1694 data: StructureProcessorListData {
1695 processors: vec![StructureProcessorKind::Rule {
1696 rules: vec![
1697 ProcessorRuleData {
1698 input_predicate: StructureRuleTestData::RandomBlockMatch {
1699 block: Identifier::vanilla_static("polished_blackstone_bricks"),
1700 probability: 0.35f32,
1701 },
1702 location_predicate: StructureRuleTestData::AlwaysTrue,
1703 position_predicate: PosRuleTestData::AlwaysTrue,
1704 output_state: BlockStateData {
1705 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
1706 properties: std::collections::BTreeMap::new(),
1707 },
1708 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1709 },
1710 ProcessorRuleData {
1711 input_predicate: StructureRuleTestData::RandomBlockMatch {
1712 block: Identifier::vanilla_static("chiseled_polished_blackstone"),
1713 probability: 0.1f32,
1714 },
1715 location_predicate: StructureRuleTestData::AlwaysTrue,
1716 position_predicate: PosRuleTestData::AlwaysTrue,
1717 output_state: BlockStateData {
1718 name: Identifier::vanilla_static("cracked_polished_blackstone_bricks"),
1719 properties: std::collections::BTreeMap::new(),
1720 },
1721 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1722 },
1723 ProcessorRuleData {
1724 input_predicate: StructureRuleTestData::RandomBlockMatch {
1725 block: Identifier::vanilla_static("gilded_blackstone"),
1726 probability: 0.5f32,
1727 },
1728 location_predicate: StructureRuleTestData::AlwaysTrue,
1729 position_predicate: PosRuleTestData::AlwaysTrue,
1730 output_state: BlockStateData {
1731 name: Identifier::vanilla_static("blackstone"),
1732 properties: std::collections::BTreeMap::new(),
1733 },
1734 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1735 },
1736 ProcessorRuleData {
1737 input_predicate: StructureRuleTestData::RandomBlockMatch {
1738 block: Identifier::vanilla_static("blackstone"),
1739 probability: 0.01f32,
1740 },
1741 location_predicate: StructureRuleTestData::AlwaysTrue,
1742 position_predicate: PosRuleTestData::AlwaysTrue,
1743 output_state: BlockStateData {
1744 name: Identifier::vanilla_static("gilded_blackstone"),
1745 properties: std::collections::BTreeMap::new(),
1746 },
1747 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1748 },
1749 ],
1750 }],
1751 },
1752 id: OnceLock::new(),
1753 });
1754pub static TRIAL_CHAMBERS_COPPER_BULB_DEGRADATION: LazyLock<StructureProcessorList> =
1755 LazyLock::new(|| StructureProcessorList {
1756 key: Identifier::vanilla_static("trial_chambers_copper_bulb_degradation"),
1757 data: StructureProcessorListData {
1758 processors: vec![
1759 StructureProcessorKind::Rule {
1760 rules: vec![
1761 ProcessorRuleData {
1762 input_predicate: StructureRuleTestData::RandomBlockMatch {
1763 block: Identifier::vanilla_static("waxed_copper_bulb"),
1764 probability: 0.1f32,
1765 },
1766 location_predicate: StructureRuleTestData::AlwaysTrue,
1767 position_predicate: PosRuleTestData::AlwaysTrue,
1768 output_state: BlockStateData {
1769 name: Identifier::vanilla_static("waxed_oxidized_copper_bulb"),
1770 properties: std::collections::BTreeMap::from([
1771 ("lit".to_owned(), "true".to_owned()),
1772 ("powered".to_owned(), "false".to_owned()),
1773 ]),
1774 },
1775 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1776 },
1777 ProcessorRuleData {
1778 input_predicate: StructureRuleTestData::RandomBlockMatch {
1779 block: Identifier::vanilla_static("waxed_copper_bulb"),
1780 probability: 0.33333334f32,
1781 },
1782 location_predicate: StructureRuleTestData::AlwaysTrue,
1783 position_predicate: PosRuleTestData::AlwaysTrue,
1784 output_state: BlockStateData {
1785 name: Identifier::vanilla_static("waxed_weathered_copper_bulb"),
1786 properties: std::collections::BTreeMap::from([
1787 ("lit".to_owned(), "true".to_owned()),
1788 ("powered".to_owned(), "false".to_owned()),
1789 ]),
1790 },
1791 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1792 },
1793 ProcessorRuleData {
1794 input_predicate: StructureRuleTestData::RandomBlockMatch {
1795 block: Identifier::vanilla_static("waxed_copper_bulb"),
1796 probability: 0.5f32,
1797 },
1798 location_predicate: StructureRuleTestData::AlwaysTrue,
1799 position_predicate: PosRuleTestData::AlwaysTrue,
1800 output_state: BlockStateData {
1801 name: Identifier::vanilla_static("waxed_exposed_copper_bulb"),
1802 properties: std::collections::BTreeMap::from([
1803 ("lit".to_owned(), "true".to_owned()),
1804 ("powered".to_owned(), "false".to_owned()),
1805 ]),
1806 },
1807 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1808 },
1809 ],
1810 },
1811 StructureProcessorKind::ProtectedBlocks {
1812 cannot_replace: Identifier::vanilla_static("features_cannot_replace"),
1813 },
1814 ],
1815 },
1816 id: OnceLock::new(),
1817 });
1818pub static ZOMBIE_DESERT: LazyLock<StructureProcessorList> =
1819 LazyLock::new(|| StructureProcessorList {
1820 key: Identifier::vanilla_static("zombie_desert"),
1821 data: StructureProcessorListData {
1822 processors: vec![StructureProcessorKind::Rule {
1823 rules: vec![
1824 ProcessorRuleData {
1825 input_predicate: StructureRuleTestData::TagMatch {
1826 tag: Identifier::vanilla_static("doors"),
1827 },
1828 location_predicate: StructureRuleTestData::AlwaysTrue,
1829 position_predicate: PosRuleTestData::AlwaysTrue,
1830 output_state: BlockStateData {
1831 name: Identifier::vanilla_static("air"),
1832 properties: std::collections::BTreeMap::new(),
1833 },
1834 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1835 },
1836 ProcessorRuleData {
1837 input_predicate: StructureRuleTestData::BlockMatch {
1838 block: Identifier::vanilla_static("torch"),
1839 },
1840 location_predicate: StructureRuleTestData::AlwaysTrue,
1841 position_predicate: PosRuleTestData::AlwaysTrue,
1842 output_state: BlockStateData {
1843 name: Identifier::vanilla_static("air"),
1844 properties: std::collections::BTreeMap::new(),
1845 },
1846 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1847 },
1848 ProcessorRuleData {
1849 input_predicate: StructureRuleTestData::BlockMatch {
1850 block: Identifier::vanilla_static("wall_torch"),
1851 },
1852 location_predicate: StructureRuleTestData::AlwaysTrue,
1853 position_predicate: PosRuleTestData::AlwaysTrue,
1854 output_state: BlockStateData {
1855 name: Identifier::vanilla_static("air"),
1856 properties: std::collections::BTreeMap::new(),
1857 },
1858 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1859 },
1860 ProcessorRuleData {
1861 input_predicate: StructureRuleTestData::RandomBlockMatch {
1862 block: Identifier::vanilla_static("smooth_sandstone"),
1863 probability: 0.08f32,
1864 },
1865 location_predicate: StructureRuleTestData::AlwaysTrue,
1866 position_predicate: PosRuleTestData::AlwaysTrue,
1867 output_state: BlockStateData {
1868 name: Identifier::vanilla_static("cobweb"),
1869 properties: std::collections::BTreeMap::new(),
1870 },
1871 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1872 },
1873 ProcessorRuleData {
1874 input_predicate: StructureRuleTestData::RandomBlockMatch {
1875 block: Identifier::vanilla_static("cut_sandstone"),
1876 probability: 0.1f32,
1877 },
1878 location_predicate: StructureRuleTestData::AlwaysTrue,
1879 position_predicate: PosRuleTestData::AlwaysTrue,
1880 output_state: BlockStateData {
1881 name: Identifier::vanilla_static("cobweb"),
1882 properties: std::collections::BTreeMap::new(),
1883 },
1884 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1885 },
1886 ProcessorRuleData {
1887 input_predicate: StructureRuleTestData::RandomBlockMatch {
1888 block: Identifier::vanilla_static("terracotta"),
1889 probability: 0.08f32,
1890 },
1891 location_predicate: StructureRuleTestData::AlwaysTrue,
1892 position_predicate: PosRuleTestData::AlwaysTrue,
1893 output_state: BlockStateData {
1894 name: Identifier::vanilla_static("cobweb"),
1895 properties: std::collections::BTreeMap::new(),
1896 },
1897 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1898 },
1899 ProcessorRuleData {
1900 input_predicate: StructureRuleTestData::RandomBlockMatch {
1901 block: Identifier::vanilla_static("smooth_sandstone_stairs"),
1902 probability: 0.08f32,
1903 },
1904 location_predicate: StructureRuleTestData::AlwaysTrue,
1905 position_predicate: PosRuleTestData::AlwaysTrue,
1906 output_state: BlockStateData {
1907 name: Identifier::vanilla_static("cobweb"),
1908 properties: std::collections::BTreeMap::new(),
1909 },
1910 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1911 },
1912 ProcessorRuleData {
1913 input_predicate: StructureRuleTestData::RandomBlockMatch {
1914 block: Identifier::vanilla_static("smooth_sandstone_slab"),
1915 probability: 0.08f32,
1916 },
1917 location_predicate: StructureRuleTestData::AlwaysTrue,
1918 position_predicate: PosRuleTestData::AlwaysTrue,
1919 output_state: BlockStateData {
1920 name: Identifier::vanilla_static("cobweb"),
1921 properties: std::collections::BTreeMap::new(),
1922 },
1923 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1924 },
1925 ProcessorRuleData {
1926 input_predicate: StructureRuleTestData::RandomBlockMatch {
1927 block: Identifier::vanilla_static("wheat"),
1928 probability: 0.2f32,
1929 },
1930 location_predicate: StructureRuleTestData::AlwaysTrue,
1931 position_predicate: PosRuleTestData::AlwaysTrue,
1932 output_state: BlockStateData {
1933 name: Identifier::vanilla_static("beetroots"),
1934 properties: std::collections::BTreeMap::from([(
1935 "age".to_owned(),
1936 "0".to_owned(),
1937 )]),
1938 },
1939 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1940 },
1941 ProcessorRuleData {
1942 input_predicate: StructureRuleTestData::RandomBlockMatch {
1943 block: Identifier::vanilla_static("wheat"),
1944 probability: 0.1f32,
1945 },
1946 location_predicate: StructureRuleTestData::AlwaysTrue,
1947 position_predicate: PosRuleTestData::AlwaysTrue,
1948 output_state: BlockStateData {
1949 name: Identifier::vanilla_static("melon_stem"),
1950 properties: std::collections::BTreeMap::from([(
1951 "age".to_owned(),
1952 "0".to_owned(),
1953 )]),
1954 },
1955 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1956 },
1957 ],
1958 }],
1959 },
1960 id: OnceLock::new(),
1961 });
1962pub static ZOMBIE_PLAINS: LazyLock<StructureProcessorList> =
1963 LazyLock::new(|| StructureProcessorList {
1964 key: Identifier::vanilla_static("zombie_plains"),
1965 data: StructureProcessorListData {
1966 processors: vec![StructureProcessorKind::Rule {
1967 rules: vec![
1968 ProcessorRuleData {
1969 input_predicate: StructureRuleTestData::RandomBlockMatch {
1970 block: Identifier::vanilla_static("cobblestone"),
1971 probability: 0.8f32,
1972 },
1973 location_predicate: StructureRuleTestData::AlwaysTrue,
1974 position_predicate: PosRuleTestData::AlwaysTrue,
1975 output_state: BlockStateData {
1976 name: Identifier::vanilla_static("mossy_cobblestone"),
1977 properties: std::collections::BTreeMap::new(),
1978 },
1979 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1980 },
1981 ProcessorRuleData {
1982 input_predicate: StructureRuleTestData::TagMatch {
1983 tag: Identifier::vanilla_static("doors"),
1984 },
1985 location_predicate: StructureRuleTestData::AlwaysTrue,
1986 position_predicate: PosRuleTestData::AlwaysTrue,
1987 output_state: BlockStateData {
1988 name: Identifier::vanilla_static("air"),
1989 properties: std::collections::BTreeMap::new(),
1990 },
1991 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
1992 },
1993 ProcessorRuleData {
1994 input_predicate: StructureRuleTestData::BlockMatch {
1995 block: Identifier::vanilla_static("torch"),
1996 },
1997 location_predicate: StructureRuleTestData::AlwaysTrue,
1998 position_predicate: PosRuleTestData::AlwaysTrue,
1999 output_state: BlockStateData {
2000 name: Identifier::vanilla_static("air"),
2001 properties: std::collections::BTreeMap::new(),
2002 },
2003 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2004 },
2005 ProcessorRuleData {
2006 input_predicate: StructureRuleTestData::BlockMatch {
2007 block: Identifier::vanilla_static("wall_torch"),
2008 },
2009 location_predicate: StructureRuleTestData::AlwaysTrue,
2010 position_predicate: PosRuleTestData::AlwaysTrue,
2011 output_state: BlockStateData {
2012 name: Identifier::vanilla_static("air"),
2013 properties: std::collections::BTreeMap::new(),
2014 },
2015 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2016 },
2017 ProcessorRuleData {
2018 input_predicate: StructureRuleTestData::RandomBlockMatch {
2019 block: Identifier::vanilla_static("cobblestone"),
2020 probability: 0.07f32,
2021 },
2022 location_predicate: StructureRuleTestData::AlwaysTrue,
2023 position_predicate: PosRuleTestData::AlwaysTrue,
2024 output_state: BlockStateData {
2025 name: Identifier::vanilla_static("cobweb"),
2026 properties: std::collections::BTreeMap::new(),
2027 },
2028 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2029 },
2030 ProcessorRuleData {
2031 input_predicate: StructureRuleTestData::RandomBlockMatch {
2032 block: Identifier::vanilla_static("mossy_cobblestone"),
2033 probability: 0.07f32,
2034 },
2035 location_predicate: StructureRuleTestData::AlwaysTrue,
2036 position_predicate: PosRuleTestData::AlwaysTrue,
2037 output_state: BlockStateData {
2038 name: Identifier::vanilla_static("cobweb"),
2039 properties: std::collections::BTreeMap::new(),
2040 },
2041 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2042 },
2043 ProcessorRuleData {
2044 input_predicate: StructureRuleTestData::RandomBlockMatch {
2045 block: Identifier::vanilla_static("white_terracotta"),
2046 probability: 0.07f32,
2047 },
2048 location_predicate: StructureRuleTestData::AlwaysTrue,
2049 position_predicate: PosRuleTestData::AlwaysTrue,
2050 output_state: BlockStateData {
2051 name: Identifier::vanilla_static("cobweb"),
2052 properties: std::collections::BTreeMap::new(),
2053 },
2054 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2055 },
2056 ProcessorRuleData {
2057 input_predicate: StructureRuleTestData::RandomBlockMatch {
2058 block: Identifier::vanilla_static("oak_log"),
2059 probability: 0.05f32,
2060 },
2061 location_predicate: StructureRuleTestData::AlwaysTrue,
2062 position_predicate: PosRuleTestData::AlwaysTrue,
2063 output_state: BlockStateData {
2064 name: Identifier::vanilla_static("cobweb"),
2065 properties: std::collections::BTreeMap::new(),
2066 },
2067 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2068 },
2069 ProcessorRuleData {
2070 input_predicate: StructureRuleTestData::RandomBlockMatch {
2071 block: Identifier::vanilla_static("oak_planks"),
2072 probability: 0.1f32,
2073 },
2074 location_predicate: StructureRuleTestData::AlwaysTrue,
2075 position_predicate: PosRuleTestData::AlwaysTrue,
2076 output_state: BlockStateData {
2077 name: Identifier::vanilla_static("cobweb"),
2078 properties: std::collections::BTreeMap::new(),
2079 },
2080 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2081 },
2082 ProcessorRuleData {
2083 input_predicate: StructureRuleTestData::RandomBlockMatch {
2084 block: Identifier::vanilla_static("oak_stairs"),
2085 probability: 0.1f32,
2086 },
2087 location_predicate: StructureRuleTestData::AlwaysTrue,
2088 position_predicate: PosRuleTestData::AlwaysTrue,
2089 output_state: BlockStateData {
2090 name: Identifier::vanilla_static("cobweb"),
2091 properties: std::collections::BTreeMap::new(),
2092 },
2093 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2094 },
2095 ProcessorRuleData {
2096 input_predicate: StructureRuleTestData::RandomBlockMatch {
2097 block: Identifier::vanilla_static("stripped_oak_log"),
2098 probability: 0.02f32,
2099 },
2100 location_predicate: StructureRuleTestData::AlwaysTrue,
2101 position_predicate: PosRuleTestData::AlwaysTrue,
2102 output_state: BlockStateData {
2103 name: Identifier::vanilla_static("cobweb"),
2104 properties: std::collections::BTreeMap::new(),
2105 },
2106 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2107 },
2108 ProcessorRuleData {
2109 input_predicate: StructureRuleTestData::RandomBlockMatch {
2110 block: Identifier::vanilla_static("glass_pane"),
2111 probability: 0.5f32,
2112 },
2113 location_predicate: StructureRuleTestData::AlwaysTrue,
2114 position_predicate: PosRuleTestData::AlwaysTrue,
2115 output_state: BlockStateData {
2116 name: Identifier::vanilla_static("cobweb"),
2117 properties: std::collections::BTreeMap::new(),
2118 },
2119 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2120 },
2121 ProcessorRuleData {
2122 input_predicate: StructureRuleTestData::BlockStateMatch {
2123 block_state: BlockStateData {
2124 name: Identifier::vanilla_static("glass_pane"),
2125 properties: std::collections::BTreeMap::from([
2126 ("east".to_owned(), "false".to_owned()),
2127 ("north".to_owned(), "true".to_owned()),
2128 ("south".to_owned(), "true".to_owned()),
2129 ("waterlogged".to_owned(), "false".to_owned()),
2130 ("west".to_owned(), "false".to_owned()),
2131 ]),
2132 },
2133 },
2134 location_predicate: StructureRuleTestData::AlwaysTrue,
2135 position_predicate: PosRuleTestData::AlwaysTrue,
2136 output_state: BlockStateData {
2137 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2138 properties: std::collections::BTreeMap::from([
2139 ("east".to_owned(), "false".to_owned()),
2140 ("north".to_owned(), "true".to_owned()),
2141 ("south".to_owned(), "true".to_owned()),
2142 ("waterlogged".to_owned(), "false".to_owned()),
2143 ("west".to_owned(), "false".to_owned()),
2144 ]),
2145 },
2146 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2147 },
2148 ProcessorRuleData {
2149 input_predicate: StructureRuleTestData::BlockStateMatch {
2150 block_state: BlockStateData {
2151 name: Identifier::vanilla_static("glass_pane"),
2152 properties: std::collections::BTreeMap::from([
2153 ("east".to_owned(), "true".to_owned()),
2154 ("north".to_owned(), "false".to_owned()),
2155 ("south".to_owned(), "false".to_owned()),
2156 ("waterlogged".to_owned(), "false".to_owned()),
2157 ("west".to_owned(), "true".to_owned()),
2158 ]),
2159 },
2160 },
2161 location_predicate: StructureRuleTestData::AlwaysTrue,
2162 position_predicate: PosRuleTestData::AlwaysTrue,
2163 output_state: BlockStateData {
2164 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2165 properties: std::collections::BTreeMap::from([
2166 ("east".to_owned(), "true".to_owned()),
2167 ("north".to_owned(), "false".to_owned()),
2168 ("south".to_owned(), "false".to_owned()),
2169 ("waterlogged".to_owned(), "false".to_owned()),
2170 ("west".to_owned(), "true".to_owned()),
2171 ]),
2172 },
2173 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2174 },
2175 ProcessorRuleData {
2176 input_predicate: StructureRuleTestData::RandomBlockMatch {
2177 block: Identifier::vanilla_static("wheat"),
2178 probability: 0.3f32,
2179 },
2180 location_predicate: StructureRuleTestData::AlwaysTrue,
2181 position_predicate: PosRuleTestData::AlwaysTrue,
2182 output_state: BlockStateData {
2183 name: Identifier::vanilla_static("carrots"),
2184 properties: std::collections::BTreeMap::from([(
2185 "age".to_owned(),
2186 "0".to_owned(),
2187 )]),
2188 },
2189 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2190 },
2191 ProcessorRuleData {
2192 input_predicate: StructureRuleTestData::RandomBlockMatch {
2193 block: Identifier::vanilla_static("wheat"),
2194 probability: 0.2f32,
2195 },
2196 location_predicate: StructureRuleTestData::AlwaysTrue,
2197 position_predicate: PosRuleTestData::AlwaysTrue,
2198 output_state: BlockStateData {
2199 name: Identifier::vanilla_static("potatoes"),
2200 properties: std::collections::BTreeMap::from([(
2201 "age".to_owned(),
2202 "0".to_owned(),
2203 )]),
2204 },
2205 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2206 },
2207 ProcessorRuleData {
2208 input_predicate: StructureRuleTestData::RandomBlockMatch {
2209 block: Identifier::vanilla_static("wheat"),
2210 probability: 0.1f32,
2211 },
2212 location_predicate: StructureRuleTestData::AlwaysTrue,
2213 position_predicate: PosRuleTestData::AlwaysTrue,
2214 output_state: BlockStateData {
2215 name: Identifier::vanilla_static("beetroots"),
2216 properties: std::collections::BTreeMap::from([(
2217 "age".to_owned(),
2218 "0".to_owned(),
2219 )]),
2220 },
2221 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2222 },
2223 ],
2224 }],
2225 },
2226 id: OnceLock::new(),
2227 });
2228pub static ZOMBIE_SAVANNA: LazyLock<StructureProcessorList> =
2229 LazyLock::new(|| StructureProcessorList {
2230 key: Identifier::vanilla_static("zombie_savanna"),
2231 data: StructureProcessorListData {
2232 processors: vec![StructureProcessorKind::Rule {
2233 rules: vec![
2234 ProcessorRuleData {
2235 input_predicate: StructureRuleTestData::TagMatch {
2236 tag: Identifier::vanilla_static("doors"),
2237 },
2238 location_predicate: StructureRuleTestData::AlwaysTrue,
2239 position_predicate: PosRuleTestData::AlwaysTrue,
2240 output_state: BlockStateData {
2241 name: Identifier::vanilla_static("air"),
2242 properties: std::collections::BTreeMap::new(),
2243 },
2244 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2245 },
2246 ProcessorRuleData {
2247 input_predicate: StructureRuleTestData::BlockMatch {
2248 block: Identifier::vanilla_static("torch"),
2249 },
2250 location_predicate: StructureRuleTestData::AlwaysTrue,
2251 position_predicate: PosRuleTestData::AlwaysTrue,
2252 output_state: BlockStateData {
2253 name: Identifier::vanilla_static("air"),
2254 properties: std::collections::BTreeMap::new(),
2255 },
2256 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2257 },
2258 ProcessorRuleData {
2259 input_predicate: StructureRuleTestData::BlockMatch {
2260 block: Identifier::vanilla_static("wall_torch"),
2261 },
2262 location_predicate: StructureRuleTestData::AlwaysTrue,
2263 position_predicate: PosRuleTestData::AlwaysTrue,
2264 output_state: BlockStateData {
2265 name: Identifier::vanilla_static("air"),
2266 properties: std::collections::BTreeMap::new(),
2267 },
2268 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2269 },
2270 ProcessorRuleData {
2271 input_predicate: StructureRuleTestData::RandomBlockMatch {
2272 block: Identifier::vanilla_static("acacia_planks"),
2273 probability: 0.2f32,
2274 },
2275 location_predicate: StructureRuleTestData::AlwaysTrue,
2276 position_predicate: PosRuleTestData::AlwaysTrue,
2277 output_state: BlockStateData {
2278 name: Identifier::vanilla_static("cobweb"),
2279 properties: std::collections::BTreeMap::new(),
2280 },
2281 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2282 },
2283 ProcessorRuleData {
2284 input_predicate: StructureRuleTestData::RandomBlockMatch {
2285 block: Identifier::vanilla_static("acacia_stairs"),
2286 probability: 0.2f32,
2287 },
2288 location_predicate: StructureRuleTestData::AlwaysTrue,
2289 position_predicate: PosRuleTestData::AlwaysTrue,
2290 output_state: BlockStateData {
2291 name: Identifier::vanilla_static("cobweb"),
2292 properties: std::collections::BTreeMap::new(),
2293 },
2294 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2295 },
2296 ProcessorRuleData {
2297 input_predicate: StructureRuleTestData::RandomBlockMatch {
2298 block: Identifier::vanilla_static("acacia_log"),
2299 probability: 0.05f32,
2300 },
2301 location_predicate: StructureRuleTestData::AlwaysTrue,
2302 position_predicate: PosRuleTestData::AlwaysTrue,
2303 output_state: BlockStateData {
2304 name: Identifier::vanilla_static("cobweb"),
2305 properties: std::collections::BTreeMap::new(),
2306 },
2307 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2308 },
2309 ProcessorRuleData {
2310 input_predicate: StructureRuleTestData::RandomBlockMatch {
2311 block: Identifier::vanilla_static("acacia_wood"),
2312 probability: 0.05f32,
2313 },
2314 location_predicate: StructureRuleTestData::AlwaysTrue,
2315 position_predicate: PosRuleTestData::AlwaysTrue,
2316 output_state: BlockStateData {
2317 name: Identifier::vanilla_static("cobweb"),
2318 properties: std::collections::BTreeMap::new(),
2319 },
2320 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2321 },
2322 ProcessorRuleData {
2323 input_predicate: StructureRuleTestData::RandomBlockMatch {
2324 block: Identifier::vanilla_static("orange_terracotta"),
2325 probability: 0.05f32,
2326 },
2327 location_predicate: StructureRuleTestData::AlwaysTrue,
2328 position_predicate: PosRuleTestData::AlwaysTrue,
2329 output_state: BlockStateData {
2330 name: Identifier::vanilla_static("cobweb"),
2331 properties: std::collections::BTreeMap::new(),
2332 },
2333 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2334 },
2335 ProcessorRuleData {
2336 input_predicate: StructureRuleTestData::RandomBlockMatch {
2337 block: Identifier::vanilla_static("yellow_terracotta"),
2338 probability: 0.05f32,
2339 },
2340 location_predicate: StructureRuleTestData::AlwaysTrue,
2341 position_predicate: PosRuleTestData::AlwaysTrue,
2342 output_state: BlockStateData {
2343 name: Identifier::vanilla_static("cobweb"),
2344 properties: std::collections::BTreeMap::new(),
2345 },
2346 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2347 },
2348 ProcessorRuleData {
2349 input_predicate: StructureRuleTestData::RandomBlockMatch {
2350 block: Identifier::vanilla_static("red_terracotta"),
2351 probability: 0.05f32,
2352 },
2353 location_predicate: StructureRuleTestData::AlwaysTrue,
2354 position_predicate: PosRuleTestData::AlwaysTrue,
2355 output_state: BlockStateData {
2356 name: Identifier::vanilla_static("cobweb"),
2357 properties: std::collections::BTreeMap::new(),
2358 },
2359 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2360 },
2361 ProcessorRuleData {
2362 input_predicate: StructureRuleTestData::RandomBlockMatch {
2363 block: Identifier::vanilla_static("glass_pane"),
2364 probability: 0.5f32,
2365 },
2366 location_predicate: StructureRuleTestData::AlwaysTrue,
2367 position_predicate: PosRuleTestData::AlwaysTrue,
2368 output_state: BlockStateData {
2369 name: Identifier::vanilla_static("cobweb"),
2370 properties: std::collections::BTreeMap::new(),
2371 },
2372 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2373 },
2374 ProcessorRuleData {
2375 input_predicate: StructureRuleTestData::BlockStateMatch {
2376 block_state: BlockStateData {
2377 name: Identifier::vanilla_static("glass_pane"),
2378 properties: std::collections::BTreeMap::from([
2379 ("east".to_owned(), "false".to_owned()),
2380 ("north".to_owned(), "true".to_owned()),
2381 ("south".to_owned(), "true".to_owned()),
2382 ("waterlogged".to_owned(), "false".to_owned()),
2383 ("west".to_owned(), "false".to_owned()),
2384 ]),
2385 },
2386 },
2387 location_predicate: StructureRuleTestData::AlwaysTrue,
2388 position_predicate: PosRuleTestData::AlwaysTrue,
2389 output_state: BlockStateData {
2390 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2391 properties: std::collections::BTreeMap::from([
2392 ("east".to_owned(), "false".to_owned()),
2393 ("north".to_owned(), "true".to_owned()),
2394 ("south".to_owned(), "true".to_owned()),
2395 ("waterlogged".to_owned(), "false".to_owned()),
2396 ("west".to_owned(), "false".to_owned()),
2397 ]),
2398 },
2399 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2400 },
2401 ProcessorRuleData {
2402 input_predicate: StructureRuleTestData::BlockStateMatch {
2403 block_state: BlockStateData {
2404 name: Identifier::vanilla_static("glass_pane"),
2405 properties: std::collections::BTreeMap::from([
2406 ("east".to_owned(), "true".to_owned()),
2407 ("north".to_owned(), "false".to_owned()),
2408 ("south".to_owned(), "false".to_owned()),
2409 ("waterlogged".to_owned(), "false".to_owned()),
2410 ("west".to_owned(), "true".to_owned()),
2411 ]),
2412 },
2413 },
2414 location_predicate: StructureRuleTestData::AlwaysTrue,
2415 position_predicate: PosRuleTestData::AlwaysTrue,
2416 output_state: BlockStateData {
2417 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2418 properties: std::collections::BTreeMap::from([
2419 ("east".to_owned(), "true".to_owned()),
2420 ("north".to_owned(), "false".to_owned()),
2421 ("south".to_owned(), "false".to_owned()),
2422 ("waterlogged".to_owned(), "false".to_owned()),
2423 ("west".to_owned(), "true".to_owned()),
2424 ]),
2425 },
2426 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2427 },
2428 ProcessorRuleData {
2429 input_predicate: StructureRuleTestData::RandomBlockMatch {
2430 block: Identifier::vanilla_static("wheat"),
2431 probability: 0.1f32,
2432 },
2433 location_predicate: StructureRuleTestData::AlwaysTrue,
2434 position_predicate: PosRuleTestData::AlwaysTrue,
2435 output_state: BlockStateData {
2436 name: Identifier::vanilla_static("melon_stem"),
2437 properties: std::collections::BTreeMap::from([(
2438 "age".to_owned(),
2439 "0".to_owned(),
2440 )]),
2441 },
2442 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2443 },
2444 ],
2445 }],
2446 },
2447 id: OnceLock::new(),
2448 });
2449pub static ZOMBIE_SNOWY: LazyLock<StructureProcessorList> =
2450 LazyLock::new(|| StructureProcessorList {
2451 key: Identifier::vanilla_static("zombie_snowy"),
2452 data: StructureProcessorListData {
2453 processors: vec![StructureProcessorKind::Rule {
2454 rules: vec![
2455 ProcessorRuleData {
2456 input_predicate: StructureRuleTestData::TagMatch {
2457 tag: Identifier::vanilla_static("doors"),
2458 },
2459 location_predicate: StructureRuleTestData::AlwaysTrue,
2460 position_predicate: PosRuleTestData::AlwaysTrue,
2461 output_state: BlockStateData {
2462 name: Identifier::vanilla_static("air"),
2463 properties: std::collections::BTreeMap::new(),
2464 },
2465 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2466 },
2467 ProcessorRuleData {
2468 input_predicate: StructureRuleTestData::BlockMatch {
2469 block: Identifier::vanilla_static("torch"),
2470 },
2471 location_predicate: StructureRuleTestData::AlwaysTrue,
2472 position_predicate: PosRuleTestData::AlwaysTrue,
2473 output_state: BlockStateData {
2474 name: Identifier::vanilla_static("air"),
2475 properties: std::collections::BTreeMap::new(),
2476 },
2477 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2478 },
2479 ProcessorRuleData {
2480 input_predicate: StructureRuleTestData::BlockMatch {
2481 block: Identifier::vanilla_static("wall_torch"),
2482 },
2483 location_predicate: StructureRuleTestData::AlwaysTrue,
2484 position_predicate: PosRuleTestData::AlwaysTrue,
2485 output_state: BlockStateData {
2486 name: Identifier::vanilla_static("air"),
2487 properties: std::collections::BTreeMap::new(),
2488 },
2489 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2490 },
2491 ProcessorRuleData {
2492 input_predicate: StructureRuleTestData::BlockMatch {
2493 block: Identifier::vanilla_static("lantern"),
2494 },
2495 location_predicate: StructureRuleTestData::AlwaysTrue,
2496 position_predicate: PosRuleTestData::AlwaysTrue,
2497 output_state: BlockStateData {
2498 name: Identifier::vanilla_static("air"),
2499 properties: std::collections::BTreeMap::new(),
2500 },
2501 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2502 },
2503 ProcessorRuleData {
2504 input_predicate: StructureRuleTestData::RandomBlockMatch {
2505 block: Identifier::vanilla_static("spruce_planks"),
2506 probability: 0.2f32,
2507 },
2508 location_predicate: StructureRuleTestData::AlwaysTrue,
2509 position_predicate: PosRuleTestData::AlwaysTrue,
2510 output_state: BlockStateData {
2511 name: Identifier::vanilla_static("cobweb"),
2512 properties: std::collections::BTreeMap::new(),
2513 },
2514 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2515 },
2516 ProcessorRuleData {
2517 input_predicate: StructureRuleTestData::RandomBlockMatch {
2518 block: Identifier::vanilla_static("spruce_slab"),
2519 probability: 0.4f32,
2520 },
2521 location_predicate: StructureRuleTestData::AlwaysTrue,
2522 position_predicate: PosRuleTestData::AlwaysTrue,
2523 output_state: BlockStateData {
2524 name: Identifier::vanilla_static("cobweb"),
2525 properties: std::collections::BTreeMap::new(),
2526 },
2527 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2528 },
2529 ProcessorRuleData {
2530 input_predicate: StructureRuleTestData::RandomBlockMatch {
2531 block: Identifier::vanilla_static("stripped_spruce_log"),
2532 probability: 0.05f32,
2533 },
2534 location_predicate: StructureRuleTestData::AlwaysTrue,
2535 position_predicate: PosRuleTestData::AlwaysTrue,
2536 output_state: BlockStateData {
2537 name: Identifier::vanilla_static("cobweb"),
2538 properties: std::collections::BTreeMap::new(),
2539 },
2540 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2541 },
2542 ProcessorRuleData {
2543 input_predicate: StructureRuleTestData::RandomBlockMatch {
2544 block: Identifier::vanilla_static("stripped_spruce_wood"),
2545 probability: 0.05f32,
2546 },
2547 location_predicate: StructureRuleTestData::AlwaysTrue,
2548 position_predicate: PosRuleTestData::AlwaysTrue,
2549 output_state: BlockStateData {
2550 name: Identifier::vanilla_static("cobweb"),
2551 properties: std::collections::BTreeMap::new(),
2552 },
2553 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2554 },
2555 ProcessorRuleData {
2556 input_predicate: StructureRuleTestData::RandomBlockMatch {
2557 block: Identifier::vanilla_static("glass_pane"),
2558 probability: 0.5f32,
2559 },
2560 location_predicate: StructureRuleTestData::AlwaysTrue,
2561 position_predicate: PosRuleTestData::AlwaysTrue,
2562 output_state: BlockStateData {
2563 name: Identifier::vanilla_static("cobweb"),
2564 properties: std::collections::BTreeMap::new(),
2565 },
2566 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2567 },
2568 ProcessorRuleData {
2569 input_predicate: StructureRuleTestData::BlockStateMatch {
2570 block_state: BlockStateData {
2571 name: Identifier::vanilla_static("glass_pane"),
2572 properties: std::collections::BTreeMap::from([
2573 ("east".to_owned(), "false".to_owned()),
2574 ("north".to_owned(), "true".to_owned()),
2575 ("south".to_owned(), "true".to_owned()),
2576 ("waterlogged".to_owned(), "false".to_owned()),
2577 ("west".to_owned(), "false".to_owned()),
2578 ]),
2579 },
2580 },
2581 location_predicate: StructureRuleTestData::AlwaysTrue,
2582 position_predicate: PosRuleTestData::AlwaysTrue,
2583 output_state: BlockStateData {
2584 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2585 properties: std::collections::BTreeMap::from([
2586 ("east".to_owned(), "false".to_owned()),
2587 ("north".to_owned(), "true".to_owned()),
2588 ("south".to_owned(), "true".to_owned()),
2589 ("waterlogged".to_owned(), "false".to_owned()),
2590 ("west".to_owned(), "false".to_owned()),
2591 ]),
2592 },
2593 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2594 },
2595 ProcessorRuleData {
2596 input_predicate: StructureRuleTestData::BlockStateMatch {
2597 block_state: BlockStateData {
2598 name: Identifier::vanilla_static("glass_pane"),
2599 properties: std::collections::BTreeMap::from([
2600 ("east".to_owned(), "true".to_owned()),
2601 ("north".to_owned(), "false".to_owned()),
2602 ("south".to_owned(), "false".to_owned()),
2603 ("waterlogged".to_owned(), "false".to_owned()),
2604 ("west".to_owned(), "true".to_owned()),
2605 ]),
2606 },
2607 },
2608 location_predicate: StructureRuleTestData::AlwaysTrue,
2609 position_predicate: PosRuleTestData::AlwaysTrue,
2610 output_state: BlockStateData {
2611 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2612 properties: std::collections::BTreeMap::from([
2613 ("east".to_owned(), "true".to_owned()),
2614 ("north".to_owned(), "false".to_owned()),
2615 ("south".to_owned(), "false".to_owned()),
2616 ("waterlogged".to_owned(), "false".to_owned()),
2617 ("west".to_owned(), "true".to_owned()),
2618 ]),
2619 },
2620 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2621 },
2622 ProcessorRuleData {
2623 input_predicate: StructureRuleTestData::RandomBlockMatch {
2624 block: Identifier::vanilla_static("wheat"),
2625 probability: 0.1f32,
2626 },
2627 location_predicate: StructureRuleTestData::AlwaysTrue,
2628 position_predicate: PosRuleTestData::AlwaysTrue,
2629 output_state: BlockStateData {
2630 name: Identifier::vanilla_static("carrots"),
2631 properties: std::collections::BTreeMap::from([(
2632 "age".to_owned(),
2633 "0".to_owned(),
2634 )]),
2635 },
2636 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2637 },
2638 ProcessorRuleData {
2639 input_predicate: StructureRuleTestData::RandomBlockMatch {
2640 block: Identifier::vanilla_static("wheat"),
2641 probability: 0.8f32,
2642 },
2643 location_predicate: StructureRuleTestData::AlwaysTrue,
2644 position_predicate: PosRuleTestData::AlwaysTrue,
2645 output_state: BlockStateData {
2646 name: Identifier::vanilla_static("potatoes"),
2647 properties: std::collections::BTreeMap::from([(
2648 "age".to_owned(),
2649 "0".to_owned(),
2650 )]),
2651 },
2652 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2653 },
2654 ],
2655 }],
2656 },
2657 id: OnceLock::new(),
2658 });
2659pub static ZOMBIE_TAIGA: LazyLock<StructureProcessorList> =
2660 LazyLock::new(|| StructureProcessorList {
2661 key: Identifier::vanilla_static("zombie_taiga"),
2662 data: StructureProcessorListData {
2663 processors: vec![StructureProcessorKind::Rule {
2664 rules: vec![
2665 ProcessorRuleData {
2666 input_predicate: StructureRuleTestData::RandomBlockMatch {
2667 block: Identifier::vanilla_static("cobblestone"),
2668 probability: 0.8f32,
2669 },
2670 location_predicate: StructureRuleTestData::AlwaysTrue,
2671 position_predicate: PosRuleTestData::AlwaysTrue,
2672 output_state: BlockStateData {
2673 name: Identifier::vanilla_static("mossy_cobblestone"),
2674 properties: std::collections::BTreeMap::new(),
2675 },
2676 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2677 },
2678 ProcessorRuleData {
2679 input_predicate: StructureRuleTestData::TagMatch {
2680 tag: Identifier::vanilla_static("doors"),
2681 },
2682 location_predicate: StructureRuleTestData::AlwaysTrue,
2683 position_predicate: PosRuleTestData::AlwaysTrue,
2684 output_state: BlockStateData {
2685 name: Identifier::vanilla_static("air"),
2686 properties: std::collections::BTreeMap::new(),
2687 },
2688 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2689 },
2690 ProcessorRuleData {
2691 input_predicate: StructureRuleTestData::BlockMatch {
2692 block: Identifier::vanilla_static("torch"),
2693 },
2694 location_predicate: StructureRuleTestData::AlwaysTrue,
2695 position_predicate: PosRuleTestData::AlwaysTrue,
2696 output_state: BlockStateData {
2697 name: Identifier::vanilla_static("air"),
2698 properties: std::collections::BTreeMap::new(),
2699 },
2700 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2701 },
2702 ProcessorRuleData {
2703 input_predicate: StructureRuleTestData::BlockMatch {
2704 block: Identifier::vanilla_static("wall_torch"),
2705 },
2706 location_predicate: StructureRuleTestData::AlwaysTrue,
2707 position_predicate: PosRuleTestData::AlwaysTrue,
2708 output_state: BlockStateData {
2709 name: Identifier::vanilla_static("air"),
2710 properties: std::collections::BTreeMap::new(),
2711 },
2712 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2713 },
2714 ProcessorRuleData {
2715 input_predicate: StructureRuleTestData::BlockMatch {
2716 block: Identifier::vanilla_static("campfire"),
2717 },
2718 location_predicate: StructureRuleTestData::AlwaysTrue,
2719 position_predicate: PosRuleTestData::AlwaysTrue,
2720 output_state: BlockStateData {
2721 name: Identifier::vanilla_static("campfire"),
2722 properties: std::collections::BTreeMap::from([
2723 ("facing".to_owned(), "north".to_owned()),
2724 ("lit".to_owned(), "false".to_owned()),
2725 ("signal_fire".to_owned(), "false".to_owned()),
2726 ("waterlogged".to_owned(), "false".to_owned()),
2727 ]),
2728 },
2729 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2730 },
2731 ProcessorRuleData {
2732 input_predicate: StructureRuleTestData::RandomBlockMatch {
2733 block: Identifier::vanilla_static("cobblestone"),
2734 probability: 0.08f32,
2735 },
2736 location_predicate: StructureRuleTestData::AlwaysTrue,
2737 position_predicate: PosRuleTestData::AlwaysTrue,
2738 output_state: BlockStateData {
2739 name: Identifier::vanilla_static("cobweb"),
2740 properties: std::collections::BTreeMap::new(),
2741 },
2742 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2743 },
2744 ProcessorRuleData {
2745 input_predicate: StructureRuleTestData::RandomBlockMatch {
2746 block: Identifier::vanilla_static("spruce_log"),
2747 probability: 0.08f32,
2748 },
2749 location_predicate: StructureRuleTestData::AlwaysTrue,
2750 position_predicate: PosRuleTestData::AlwaysTrue,
2751 output_state: BlockStateData {
2752 name: Identifier::vanilla_static("cobweb"),
2753 properties: std::collections::BTreeMap::new(),
2754 },
2755 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2756 },
2757 ProcessorRuleData {
2758 input_predicate: StructureRuleTestData::RandomBlockMatch {
2759 block: Identifier::vanilla_static("glass_pane"),
2760 probability: 0.5f32,
2761 },
2762 location_predicate: StructureRuleTestData::AlwaysTrue,
2763 position_predicate: PosRuleTestData::AlwaysTrue,
2764 output_state: BlockStateData {
2765 name: Identifier::vanilla_static("cobweb"),
2766 properties: std::collections::BTreeMap::new(),
2767 },
2768 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2769 },
2770 ProcessorRuleData {
2771 input_predicate: StructureRuleTestData::BlockStateMatch {
2772 block_state: BlockStateData {
2773 name: Identifier::vanilla_static("glass_pane"),
2774 properties: std::collections::BTreeMap::from([
2775 ("east".to_owned(), "false".to_owned()),
2776 ("north".to_owned(), "true".to_owned()),
2777 ("south".to_owned(), "true".to_owned()),
2778 ("waterlogged".to_owned(), "false".to_owned()),
2779 ("west".to_owned(), "false".to_owned()),
2780 ]),
2781 },
2782 },
2783 location_predicate: StructureRuleTestData::AlwaysTrue,
2784 position_predicate: PosRuleTestData::AlwaysTrue,
2785 output_state: BlockStateData {
2786 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2787 properties: std::collections::BTreeMap::from([
2788 ("east".to_owned(), "false".to_owned()),
2789 ("north".to_owned(), "true".to_owned()),
2790 ("south".to_owned(), "true".to_owned()),
2791 ("waterlogged".to_owned(), "false".to_owned()),
2792 ("west".to_owned(), "false".to_owned()),
2793 ]),
2794 },
2795 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2796 },
2797 ProcessorRuleData {
2798 input_predicate: StructureRuleTestData::BlockStateMatch {
2799 block_state: BlockStateData {
2800 name: Identifier::vanilla_static("glass_pane"),
2801 properties: std::collections::BTreeMap::from([
2802 ("east".to_owned(), "true".to_owned()),
2803 ("north".to_owned(), "false".to_owned()),
2804 ("south".to_owned(), "false".to_owned()),
2805 ("waterlogged".to_owned(), "false".to_owned()),
2806 ("west".to_owned(), "true".to_owned()),
2807 ]),
2808 },
2809 },
2810 location_predicate: StructureRuleTestData::AlwaysTrue,
2811 position_predicate: PosRuleTestData::AlwaysTrue,
2812 output_state: BlockStateData {
2813 name: Identifier::vanilla_static("brown_stained_glass_pane"),
2814 properties: std::collections::BTreeMap::from([
2815 ("east".to_owned(), "true".to_owned()),
2816 ("north".to_owned(), "false".to_owned()),
2817 ("south".to_owned(), "false".to_owned()),
2818 ("waterlogged".to_owned(), "false".to_owned()),
2819 ("west".to_owned(), "true".to_owned()),
2820 ]),
2821 },
2822 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2823 },
2824 ProcessorRuleData {
2825 input_predicate: StructureRuleTestData::RandomBlockMatch {
2826 block: Identifier::vanilla_static("wheat"),
2827 probability: 0.3f32,
2828 },
2829 location_predicate: StructureRuleTestData::AlwaysTrue,
2830 position_predicate: PosRuleTestData::AlwaysTrue,
2831 output_state: BlockStateData {
2832 name: Identifier::vanilla_static("pumpkin_stem"),
2833 properties: std::collections::BTreeMap::from([(
2834 "age".to_owned(),
2835 "0".to_owned(),
2836 )]),
2837 },
2838 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2839 },
2840 ProcessorRuleData {
2841 input_predicate: StructureRuleTestData::RandomBlockMatch {
2842 block: Identifier::vanilla_static("wheat"),
2843 probability: 0.2f32,
2844 },
2845 location_predicate: StructureRuleTestData::AlwaysTrue,
2846 position_predicate: PosRuleTestData::AlwaysTrue,
2847 output_state: BlockStateData {
2848 name: Identifier::vanilla_static("potatoes"),
2849 properties: std::collections::BTreeMap::from([(
2850 "age".to_owned(),
2851 "0".to_owned(),
2852 )]),
2853 },
2854 block_entity_modifier: RuleBlockEntityModifierData::Passthrough,
2855 },
2856 ],
2857 }],
2858 },
2859 id: OnceLock::new(),
2860 });
2861pub fn register_structure_processor_lists(registry: &mut StructureProcessorListRegistry) {
2862 registry.register(&ANCIENT_CITY_GENERIC_DEGRADATION);
2863 registry.register(&ANCIENT_CITY_START_DEGRADATION);
2864 registry.register(&ANCIENT_CITY_WALLS_DEGRADATION);
2865 registry.register(&BASTION_GENERIC_DEGRADATION);
2866 registry.register(&BOTTOM_RAMPART);
2867 registry.register(&BRIDGE);
2868 registry.register(&EMPTY);
2869 registry.register(&ENTRANCE_REPLACEMENT);
2870 registry.register(&FARM_DESERT);
2871 registry.register(&FARM_PLAINS);
2872 registry.register(&FARM_SAVANNA);
2873 registry.register(&FARM_SNOWY);
2874 registry.register(&FARM_TAIGA);
2875 registry.register(&FOSSIL_COAL);
2876 registry.register(&FOSSIL_DIAMONDS);
2877 registry.register(&FOSSIL_ROT);
2878 registry.register(&HIGH_RAMPART);
2879 registry.register(&HIGH_WALL);
2880 registry.register(&HOUSING);
2881 registry.register(&MOSSIFY_10_PERCENT);
2882 registry.register(&MOSSIFY_20_PERCENT);
2883 registry.register(&MOSSIFY_70_PERCENT);
2884 registry.register(&OUTPOST_ROT);
2885 registry.register(&RAMPART_DEGRADATION);
2886 registry.register(&ROOF);
2887 registry.register(&SIDE_WALL_DEGRADATION);
2888 registry.register(&STABLE_DEGRADATION);
2889 registry.register(&STREET_PLAINS);
2890 registry.register(&STREET_SAVANNA);
2891 registry.register(&STREET_SNOWY_OR_TAIGA);
2892 registry.register(&TRAIL_RUINS_HOUSES_ARCHAEOLOGY);
2893 registry.register(&TRAIL_RUINS_ROADS_ARCHAEOLOGY);
2894 registry.register(&TRAIL_RUINS_TOWER_TOP_ARCHAEOLOGY);
2895 registry.register(&TREASURE_ROOMS);
2896 registry.register(&TRIAL_CHAMBERS_COPPER_BULB_DEGRADATION);
2897 registry.register(&ZOMBIE_DESERT);
2898 registry.register(&ZOMBIE_PLAINS);
2899 registry.register(&ZOMBIE_SAVANNA);
2900 registry.register(&ZOMBIE_SNOWY);
2901 registry.register(&ZOMBIE_TAIGA);
2902}