From 6c0ff59403b2f67afa7f580814bfc44c5f7fdd32 Mon Sep 17 00:00:00 2001 From: Jeremy Peifer Date: Fri, 22 Mar 2024 20:24:06 -0700 Subject: [PATCH] 1.0.2; finished ore "collection" file, designed to support vanilla and modded stone types that presently do not have ore variants. --- .../spiromodnext/core/init/Registry.java | 279 +------- .../registry/data/OreBlockCollection.java | 43 -- .../init/registry/data/OreCollection.java | 672 ++++++++++++++++++ 3 files changed, 696 insertions(+), 298 deletions(-) delete mode 100644 src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreBlockCollection.java create mode 100644 src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreCollection.java diff --git a/src/main/java/com/github/peeftube/spiromodnext/core/init/Registry.java b/src/main/java/com/github/peeftube/spiromodnext/core/init/Registry.java index 9daa64e..90e26f4 100644 --- a/src/main/java/com/github/peeftube/spiromodnext/core/init/Registry.java +++ b/src/main/java/com/github/peeftube/spiromodnext/core/init/Registry.java @@ -14,6 +14,8 @@ import net.neoforged.neoforge.registries.DeferredItem; import net.neoforged.neoforge.registries.DeferredRegister; +import java.util.function.Supplier; + public class Registry { // Create a Deferred Register to hold Items which will all be registered under the "examplemod" namespace @@ -52,259 +54,26 @@ public static void init() public static final DeferredRegister.Blocks BLOCKS = DeferredRegister.createBlocks(SpiroMod.MOD_ID); public static final DeferredRegister.Items ITEMS = DeferredRegister.createItems(SpiroMod.MOD_ID); - public static final DeferredBlock DIORITE_COAL = BLOCKS.register("diorite_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_COAL = BLOCKS.register("granite_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_COAL = BLOCKS.register("andesite_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_COAL = BLOCKS.register("calcite_coal_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_COAL = BLOCKS.register("sandstone_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_COAL = BLOCKS.register("red_sandstone_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_COAL = BLOCKS.register("sm_sandstone_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_COAL = BLOCKS.register("sm_red_sandstone_coal_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_COAL = BLOCKS.register("tuff_coal_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_COAL = BLOCKS.register("dripstone_coal_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_COAL_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_COAL); - public static final DeferredItem GRANITE_COAL_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_COAL); - public static final DeferredItem ANDESITE_COAL_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_COAL); - public static final DeferredItem CALCITE_COAL_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_COAL); - public static final DeferredItem S_COAL_ITEM = ITEMS.registerSimpleBlockItem(S_COAL); - public static final DeferredItem RS_COAL_ITEM = ITEMS.registerSimpleBlockItem(RS_COAL); - public static final DeferredItem SMS_COAL_ITEM = ITEMS.registerSimpleBlockItem(SMS_COAL); - public static final DeferredItem SMRS_COAL_ITEM = ITEMS.registerSimpleBlockItem(SMRS_COAL); - public static final DeferredItem TUFF_COAL_ITEM = ITEMS.registerSimpleBlockItem(TUFF_COAL); - public static final DeferredItem DRIPSTONE_COAL_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_COAL); - - public static final DeferredBlock DIORITE_COPPER = BLOCKS.register("diorite_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_COPPER = BLOCKS.register("granite_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_COPPER = BLOCKS.register("andesite_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_COPPER = BLOCKS.register("calcite_copper_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_COPPER = BLOCKS.register("sandstone_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_COPPER = BLOCKS.register("red_sandstone_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_COPPER = BLOCKS.register("sm_sandstone_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_COPPER = BLOCKS.register("sm_red_sandstone_copper_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_COPPER = BLOCKS.register("tuff_copper_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_COPPER = BLOCKS.register("dripstone_copper_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_COPPER_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_COPPER); - public static final DeferredItem GRANITE_COPPER_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_COPPER); - public static final DeferredItem ANDESITE_COPPER_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_COPPER); - public static final DeferredItem CALCITE_COPPER_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_COPPER); - public static final DeferredItem S_COPPER_ITEM = ITEMS.registerSimpleBlockItem(S_COPPER); - public static final DeferredItem RS_COPPER_ITEM = ITEMS.registerSimpleBlockItem(RS_COPPER); - public static final DeferredItem SMS_COPPER_ITEM = ITEMS.registerSimpleBlockItem(SMS_COPPER); - public static final DeferredItem SMRS_COPPER_ITEM = ITEMS.registerSimpleBlockItem(SMRS_COPPER); - public static final DeferredItem TUFF_COPPER_ITEM = ITEMS.registerSimpleBlockItem(TUFF_COPPER); - public static final DeferredItem DRIPSTONE_COPPER_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_COPPER); - - public static final DeferredBlock DIORITE_IRON = BLOCKS.register("diorite_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_IRON = BLOCKS.register("granite_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_IRON = BLOCKS.register("andesite_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_IRON = BLOCKS.register("calcite_iron_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_IRON = BLOCKS.register("sandstone_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_IRON = BLOCKS.register("red_sandstone_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_IRON = BLOCKS.register("sm_sandstone_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_IRON = BLOCKS.register("sm_red_sandstone_iron_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_IRON = BLOCKS.register("tuff_iron_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_IRON = BLOCKS.register("dripstone_iron_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_IRON_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_IRON); - public static final DeferredItem GRANITE_IRON_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_IRON); - public static final DeferredItem ANDESITE_IRON_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_IRON); - public static final DeferredItem CALCITE_IRON_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_IRON); - public static final DeferredItem S_IRON_ITEM = ITEMS.registerSimpleBlockItem(S_IRON); - public static final DeferredItem RS_IRON_ITEM = ITEMS.registerSimpleBlockItem(RS_IRON); - public static final DeferredItem SMS_IRON_ITEM = ITEMS.registerSimpleBlockItem(SMS_IRON); - public static final DeferredItem SMRS_IRON_ITEM = ITEMS.registerSimpleBlockItem(SMRS_IRON); - public static final DeferredItem TUFF_IRON_ITEM = ITEMS.registerSimpleBlockItem(TUFF_IRON); - public static final DeferredItem DRIPSTONE_IRON_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_IRON); - - public static final DeferredBlock DIORITE_LAPIS = BLOCKS.register("diorite_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_LAPIS = BLOCKS.register("granite_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_LAPIS = BLOCKS.register("andesite_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_LAPIS = BLOCKS.register("calcite_lapis_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_LAPIS = BLOCKS.register("sandstone_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_LAPIS = BLOCKS.register("red_sandstone_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_LAPIS = BLOCKS.register("sm_sandstone_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_LAPIS = BLOCKS.register("sm_red_sandstone_lapis_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_LAPIS = BLOCKS.register("tuff_lapis_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_LAPIS = BLOCKS.register("dripstone_lapis_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_LAPIS); - public static final DeferredItem GRANITE_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_LAPIS); - public static final DeferredItem ANDESITE_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_LAPIS); - public static final DeferredItem CALCITE_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_LAPIS); - public static final DeferredItem S_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(S_LAPIS); - public static final DeferredItem RS_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(RS_LAPIS); - public static final DeferredItem SMS_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(SMS_LAPIS); - public static final DeferredItem SMRS_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(SMRS_LAPIS); - public static final DeferredItem TUFF_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(TUFF_LAPIS); - public static final DeferredItem DRIPSTONE_LAPIS_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_LAPIS); - - public static final DeferredBlock DIORITE_REDSTONE = BLOCKS.register("diorite_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_REDSTONE = BLOCKS.register("granite_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_REDSTONE = BLOCKS.register("andesite_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_REDSTONE = BLOCKS.register("calcite_redstone_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_REDSTONE = BLOCKS.register("sandstone_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_REDSTONE = BLOCKS.register("red_sandstone_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_REDSTONE = BLOCKS.register("sm_sandstone_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_REDSTONE = BLOCKS.register("sm_red_sandstone_redstone_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_REDSTONE = BLOCKS.register("tuff_redstone_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_REDSTONE = BLOCKS.register("dripstone_redstone_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_REDSTONE); - public static final DeferredItem GRANITE_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_REDSTONE); - public static final DeferredItem ANDESITE_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_REDSTONE); - public static final DeferredItem CALCITE_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_REDSTONE); - public static final DeferredItem S_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(S_REDSTONE); - public static final DeferredItem RS_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(RS_REDSTONE); - public static final DeferredItem SMS_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(SMS_REDSTONE); - public static final DeferredItem SMRS_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(SMRS_REDSTONE); - public static final DeferredItem TUFF_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(TUFF_REDSTONE); - public static final DeferredItem DRIPSTONE_REDSTONE_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_REDSTONE); - - public static final DeferredBlock DIORITE_GOLD = BLOCKS.register("diorite_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_GOLD = BLOCKS.register("granite_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_GOLD = BLOCKS.register("andesite_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_GOLD = BLOCKS.register("calcite_gold_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_GOLD = BLOCKS.register("sandstone_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_GOLD = BLOCKS.register("red_sandstone_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_GOLD = BLOCKS.register("sm_sandstone_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_GOLD = BLOCKS.register("sm_red_sandstone_gold_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_GOLD = BLOCKS.register("tuff_gold_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_GOLD = BLOCKS.register("dripstone_gold_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_GOLD_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_GOLD); - public static final DeferredItem GRANITE_GOLD_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_GOLD); - public static final DeferredItem ANDESITE_GOLD_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_GOLD); - public static final DeferredItem CALCITE_GOLD_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_GOLD); - public static final DeferredItem S_GOLD_ITEM = ITEMS.registerSimpleBlockItem(S_GOLD); - public static final DeferredItem RS_GOLD_ITEM = ITEMS.registerSimpleBlockItem(RS_GOLD); - public static final DeferredItem SMS_GOLD_ITEM = ITEMS.registerSimpleBlockItem(SMS_GOLD); - public static final DeferredItem SMRS_GOLD_ITEM = ITEMS.registerSimpleBlockItem(SMRS_GOLD); - public static final DeferredItem TUFF_GOLD_ITEM = ITEMS.registerSimpleBlockItem(TUFF_GOLD); - public static final DeferredItem DRIPSTONE_GOLD_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_GOLD); - - public static final DeferredBlock DIORITE_DIAMOND = BLOCKS.register("diorite_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_DIAMOND = BLOCKS.register("granite_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_DIAMOND = BLOCKS.register("andesite_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_DIAMOND = BLOCKS.register("calcite_diamond_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_DIAMOND = BLOCKS.register("sandstone_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_DIAMOND = BLOCKS.register("red_sandstone_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_DIAMOND = BLOCKS.register("sm_sandstone_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_DIAMOND = BLOCKS.register("sm_red_sandstone_diamond_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_DIAMOND = BLOCKS.register("tuff_diamond_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_DIAMOND = BLOCKS.register("dripstone_diamond_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_DIAMOND); - public static final DeferredItem GRANITE_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_DIAMOND); - public static final DeferredItem ANDESITE_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_DIAMOND); - public static final DeferredItem CALCITE_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_DIAMOND); - public static final DeferredItem S_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(S_DIAMOND); - public static final DeferredItem RS_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(RS_DIAMOND); - public static final DeferredItem SMS_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(SMS_DIAMOND); - public static final DeferredItem SMRS_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(SMRS_DIAMOND); - public static final DeferredItem TUFF_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(TUFF_DIAMOND); - public static final DeferredItem DRIPSTONE_DIAMOND_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_DIAMOND); - - public static final DeferredBlock DIORITE_EMERALD = BLOCKS.register("diorite_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock GRANITE_EMERALD = BLOCKS.register("granite_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock ANDESITE_EMERALD = BLOCKS.register("andesite_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock CALCITE_EMERALD = BLOCKS.register("calcite_emerald_ore", - () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock S_EMERALD = BLOCKS.register("sandstone_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock RS_EMERALD = BLOCKS.register("red_sandstone_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMS_EMERALD = BLOCKS.register("sm_sandstone_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock SMRS_EMERALD = BLOCKS.register("sm_red_sandstone_emerald_ore", - () -> new Block(STONE_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock TUFF_EMERALD = BLOCKS.register("tuff_emerald_ore", - () -> new Block(TUFF_BASED_ORE.lightLevel(s -> 0))); - public static final DeferredBlock DRIPSTONE_EMERALD = BLOCKS.register("dripstone_emerald_ore", - () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> 0))); - - public static final DeferredItem DIORITE_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(DIORITE_EMERALD); - public static final DeferredItem GRANITE_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(GRANITE_EMERALD); - public static final DeferredItem ANDESITE_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(ANDESITE_EMERALD); - public static final DeferredItem CALCITE_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(CALCITE_EMERALD); - public static final DeferredItem S_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(S_EMERALD); - public static final DeferredItem RS_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(RS_EMERALD); - public static final DeferredItem SMS_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(SMS_EMERALD); - public static final DeferredItem SMRS_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(SMRS_EMERALD); - public static final DeferredItem TUFF_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(TUFF_EMERALD); - public static final DeferredItem DRIPSTONE_EMERALD_ITEM = ITEMS.registerSimpleBlockItem(DRIPSTONE_EMERALD); + // Based on Nyfaria's code: + // https://shorturl.at/bktNR + public static DeferredBlock regBlock(String name, Supplier block) + { return BLOCKS.register(name, block); } + + public static DeferredItem regSimpleBlockItem(DeferredBlock block) + { return (DeferredItem) ITEMS.registerSimpleBlockItem(block); } + + public static final BlockBehaviour.Properties STONE_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.NORMAL.get()).sound(SoundType.STONE); + public static final BlockBehaviour.Properties TUFF_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.NORMAL.get()).sound(SoundType.TUFF); + public static final BlockBehaviour.Properties DRIPSTONE_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.NORMAL.get()).sound(SoundType.DRIPSTONE_BLOCK); + public static final BlockBehaviour.Properties DEEPSLATE_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.TOUGH.get()).sound(SoundType.DEEPSLATE); + public static final BlockBehaviour.Properties CALCITE_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.WEAK.get()).sound(SoundType.CALCITE); + public static final BlockBehaviour.Properties NETHER_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.WEAK.get()).sound(SoundType.NETHERRACK); + public static final BlockBehaviour.Properties BASALT_BASED_ORE = + BlockBehaviour.Properties.of().strength(BlockToughness.WEAK.get()).sound(SoundType.BASALT); } diff --git a/src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreBlockCollection.java b/src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreBlockCollection.java deleted file mode 100644 index ed98b2a..0000000 --- a/src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreBlockCollection.java +++ /dev/null @@ -1,43 +0,0 @@ -package com.github.peeftube.spiromodnext.core.init.registry.data; - -import net.minecraft.world.item.BlockItem; -import net.minecraft.world.level.block.Block; -import net.minecraft.world.level.block.SoundType; -import net.minecraft.world.level.block.state.BlockBehaviour; -import net.neoforged.neoforge.registries.DeferredBlock; -import net.neoforged.neoforge.registries.DeferredItem; - -public record OreBlockCollection(String name, - DeferredBlock defaultOre, DeferredItem defaultItem, - DeferredBlock andesiteOre, DeferredItem andesiteItem, - DeferredBlock dioriteOre, DeferredItem dioriteItem, - DeferredBlock graniteOre, DeferredItem graniteItem, - DeferredBlock calciteOre, DeferredItem calciteItem, - DeferredBlock saStOre, DeferredItem saStItem, - DeferredBlock smtSaStOre, DeferredItem smtSaStItem, - DeferredBlock redSaStOre, DeferredItem redSaStItem, - DeferredBlock smtRedSaStOre, DeferredItem smtRedSaStItem, - DeferredBlock deepslateOre, DeferredItem deepslateItem, - DeferredBlock tuffOre, DeferredItem tuffItem, - DeferredBlock dripstoneOre, DeferredItem dripstoneItem, - DeferredBlock blackstoneOre, DeferredItem blackstoneItem, - DeferredBlock netherrackOre, DeferredItem netherrackItem, - DeferredBlock basaltOre, DeferredItem basaltItem, - DeferredBlock smtBasaltOre, DeferredItem smtBasaltItem, - DeferredBlock endstoneOre, DeferredItem endstoneItem) -{ - public static final BlockBehaviour.Properties STONE_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.NORMAL.get()).sound(SoundType.STONE); - public static final BlockBehaviour.Properties TUFF_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.NORMAL.get()).sound(SoundType.TUFF); - public static final BlockBehaviour.Properties DRIPSTONE_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.NORMAL.get()).sound(SoundType.DRIPSTONE_BLOCK); - public static final BlockBehaviour.Properties DEEPSLATE_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.TOUGH.get()).sound(SoundType.DEEPSLATE); - public static final BlockBehaviour.Properties CALCITE_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.WEAK.get()).sound(SoundType.CALCITE); - public static final BlockBehaviour.Properties NETHER_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.WEAK.get()).sound(SoundType.NETHERRACK); - public static final BlockBehaviour.Properties BASALT_BASED_ORE = - BlockBehaviour.Properties.of().strength(BlockToughness.WEAK.get()).sound(SoundType.BASALT); -} diff --git a/src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreCollection.java b/src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreCollection.java new file mode 100644 index 0000000..c1b13b8 --- /dev/null +++ b/src/main/java/com/github/peeftube/spiromodnext/core/init/registry/data/OreCollection.java @@ -0,0 +1,672 @@ +package com.github.peeftube.spiromodnext.core.init.registry.data; + +import com.github.peeftube.spiromodnext.core.init.Registry; +import net.minecraft.world.item.Item; +import net.minecraft.world.item.Items; +import net.minecraft.world.item.crafting.Ingredient; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.Blocks; +import net.neoforged.neoforge.registries.DeferredBlock; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Supplier; + +import static com.github.peeftube.spiromodnext.core.init.Registry.*; + +public record OreCollection(String name, + Supplier defaultOre, Supplier defaultItem, + Supplier andesiteOre, Supplier andesiteItem, + Supplier dioriteOre, Supplier dioriteItem, + Supplier graniteOre, Supplier graniteItem, + Supplier calciteOre, Supplier calciteItem, + Supplier saStOre, Supplier saStItem, + Supplier smtSaStOre, Supplier smtSaStItem, + Supplier redSaStOre, Supplier redSaStItem, + Supplier smtRedSaStOre, Supplier smtRedSaStItem, + Supplier deepslateOre, Supplier deepslateItem, + Supplier tuffOre, Supplier tuffItem, + Supplier dripstoneOre, Supplier dripstoneItem, + Supplier netherrackOre, Supplier netherrackItem, + Supplier basaltOre, Supplier basaltItem, + Supplier endstoneOre, Supplier endstoneItem) +{ + public static List ORE_COLLECTIONS = new ArrayList<>(); + + // Protected enum for internal class use. + protected static enum BaseStone + { + STONE(""), ANDESITE("andesite_"), DIORITE("diorite_"), + GRANITE("granite_"), CALCITE("calcite_"), SANDSTONE("sandstone_"), + SMSAST("smooth_sandstone_"), RSAST("red_sandstone_"), SMRSAST("smooth_red_sandstone_"), + DEEPSLATE("deepslate_"), TUFF("tuff_"), DRIPSTONE("dripstone_"), + NETHERRACK("nether_"), BASALT("basalt_"), ENDSTONE("end_"); + + private String name; + + private BaseStone(String name) + { this.name = name; } + + public String get() + { return name; } + } + + public static OreCollection registerCollection(String name) + { return registerCollection(name, 0); } + + public static OreCollection registerCollection(String name, int lightEmissionLevel) + { + String oreName = name + "_ore"; + int li = lightEmissionLevel; + + // Prepare all desired possible vanilla variants ahead of time + Supplier defaultOre; Supplier defaultItem; + Supplier andesiteOre; Supplier andesiteItem; + Supplier dioriteOre; Supplier dioriteItem; + Supplier graniteOre; Supplier graniteItem; + Supplier calciteOre; Supplier calciteItem; + Supplier saStOre; Supplier saStItem; + Supplier smtSaStOre; Supplier smtSaStItem; + Supplier redSaStOre; Supplier redSaStItem; + Supplier smtRedSaStOre; Supplier smtRedSaStItem; + Supplier deepslateOre; Supplier deepslateItem; + Supplier tuffOre; Supplier tuffItem; + Supplier dripstoneOre; Supplier dripstoneItem; + Supplier netherrackOre; Supplier netherrackItem; + Supplier basaltOre; Supplier basaltItem; + Supplier endstoneOre; Supplier endstoneItem; + + switch(name) + { + case "coal": + defaultOre = () -> Blocks.COAL_ORE; + defaultItem = () -> Items.COAL_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_COAL_ORE; + deepslateItem = () -> Items.DEEPSLATE_COAL_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "iron": + defaultOre = () -> Blocks.IRON_ORE; + defaultItem = () -> Items.IRON_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_IRON_ORE; + deepslateItem = () -> Items.DEEPSLATE_IRON_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "copper": + defaultOre = () -> Blocks.COPPER_ORE; + defaultItem = () -> Items.COPPER_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_COPPER_ORE; + deepslateItem = () -> Items.DEEPSLATE_COPPER_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "gold": + defaultOre = () -> Blocks.GOLD_ORE; + defaultItem = () -> Items.GOLD_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_GOLD_ORE; + deepslateItem = () -> Items.DEEPSLATE_GOLD_ORE; + netherrackOre = () -> Blocks.NETHER_GOLD_ORE; + netherrackItem = () -> Items.NETHER_GOLD_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "lapis": + defaultOre = () -> Blocks.LAPIS_ORE; + defaultItem = () -> Items.LAPIS_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_LAPIS_ORE; + deepslateItem = () -> Items.DEEPSLATE_LAPIS_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "redstone": + defaultOre = () -> Blocks.REDSTONE_ORE; + defaultItem = () -> Items.REDSTONE_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_REDSTONE_ORE; + deepslateItem = () -> Items.DEEPSLATE_REDSTONE_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "diamond": + defaultOre = () -> Blocks.DIAMOND_ORE; + defaultItem = () -> Items.DIAMOND_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_DIAMOND_ORE; + deepslateItem = () -> Items.DEEPSLATE_DIAMOND_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "emerald": + defaultOre = () -> Blocks.EMERALD_ORE; + defaultItem = () -> Items.EMERALD_ORE; + deepslateOre = () -> Blocks.DEEPSLATE_EMERALD_ORE; + deepslateItem = () -> Items.DEEPSLATE_EMERALD_ORE; + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + case "quartz": + netherrackOre = () -> Blocks.NETHER_QUARTZ_ORE; + netherrackItem = () -> Items.NETHER_QUARTZ_ORE; + + defaultOre = Registry.regBlock(BaseStone.STONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + defaultItem = Registry.regSimpleBlockItem((DeferredBlock) defaultOre); + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + deepslateOre = Registry.regBlock(BaseStone.DEEPSLATE.get() + oreName, + () -> new Block(DEEPSLATE_BASED_ORE.lightLevel(s -> li))); + deepslateItem = Registry.regSimpleBlockItem((DeferredBlock) deepslateOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + default: + defaultOre = Registry.regBlock(BaseStone.STONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + defaultItem = Registry.regSimpleBlockItem((DeferredBlock) defaultOre); + + andesiteOre = Registry.regBlock(BaseStone.ANDESITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + andesiteItem = Registry.regSimpleBlockItem((DeferredBlock) andesiteOre); + + dioriteOre = Registry.regBlock(BaseStone.DIORITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + dioriteItem = Registry.regSimpleBlockItem((DeferredBlock) dioriteOre); + + graniteOre = Registry.regBlock(BaseStone.GRANITE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + graniteItem = Registry.regSimpleBlockItem((DeferredBlock) graniteOre); + + calciteOre = Registry.regBlock(BaseStone.CALCITE.get() + oreName, + () -> new Block(CALCITE_BASED_ORE.lightLevel(s -> li))); + calciteItem = Registry.regSimpleBlockItem((DeferredBlock) calciteOre); + + saStOre = Registry.regBlock(BaseStone.SANDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + saStItem = Registry.regSimpleBlockItem((DeferredBlock) saStOre); + + smtSaStOre = Registry.regBlock(BaseStone.SMSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtSaStOre); + + redSaStOre = Registry.regBlock(BaseStone.RSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + redSaStItem = Registry.regSimpleBlockItem((DeferredBlock) redSaStOre); + + smtRedSaStOre = Registry.regBlock(BaseStone.SMRSAST.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + smtRedSaStItem = Registry.regSimpleBlockItem((DeferredBlock) smtRedSaStOre); + + deepslateOre = Registry.regBlock(BaseStone.DEEPSLATE.get() + oreName, + () -> new Block(DEEPSLATE_BASED_ORE.lightLevel(s -> li))); + deepslateItem = Registry.regSimpleBlockItem((DeferredBlock) deepslateOre); + + tuffOre = Registry.regBlock(BaseStone.TUFF.get() + oreName, + () -> new Block(TUFF_BASED_ORE.lightLevel(s -> li))); + tuffItem = Registry.regSimpleBlockItem((DeferredBlock) tuffOre); + + dripstoneOre = Registry.regBlock(BaseStone.DRIPSTONE.get() + oreName, + () -> new Block(DRIPSTONE_BASED_ORE.lightLevel(s -> li))); + dripstoneItem = Registry.regSimpleBlockItem((DeferredBlock) dripstoneOre); + + netherrackOre = Registry.regBlock(BaseStone.NETHERRACK.get() + oreName, + () -> new Block(NETHER_BASED_ORE.lightLevel(s -> li))); + netherrackItem = Registry.regSimpleBlockItem((DeferredBlock) netherrackOre); + + basaltOre = Registry.regBlock(BaseStone.BASALT.get() + oreName, + () -> new Block(BASALT_BASED_ORE.lightLevel(s -> li))); + basaltItem = Registry.regSimpleBlockItem((DeferredBlock) basaltOre); + + endstoneOre = Registry.regBlock(BaseStone.ENDSTONE.get() + oreName, + () -> new Block(STONE_BASED_ORE.lightLevel(s -> li))); + endstoneItem = Registry.regSimpleBlockItem((DeferredBlock) endstoneOre); + break; + } + OreCollection collection = new OreCollection(name, defaultOre, defaultItem, andesiteOre, andesiteItem, + dioriteOre, dioriteItem, graniteOre, graniteItem, calciteOre, calciteItem, + saStOre, saStItem, smtSaStOre, smtSaStItem, redSaStOre, redSaStItem, smtRedSaStOre, smtRedSaStItem, + deepslateOre, deepslateItem, tuffOre, tuffItem, dripstoneOre, dripstoneItem, + netherrackOre, netherrackItem, basaltOre, basaltItem, endstoneOre, endstoneItem); + ORE_COLLECTIONS.add(collection); return collection; + } +}