diff --git a/1.20.1-common/src/main/java/net/meatwo310/softdeepslate/SoftDeepslateLogic.java b/1.20.1-common/src/main/java/net/meatwo310/softdeepslate/SoftDeepslateLogic.java new file mode 100644 index 0000000..7526d68 --- /dev/null +++ b/1.20.1-common/src/main/java/net/meatwo310/softdeepslate/SoftDeepslateLogic.java @@ -0,0 +1,111 @@ +package net.meatwo310.softdeepslate; + +import net.meatwo310.softdeepslate.config.ModServerConfig; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.BlockState; + +import java.util.HashSet; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; + +public final class SoftDeepslateLogic { + private final ModServerConfig config; + private final BlockResolver blockResolver; + private volatile Set blocksCache; + + public SoftDeepslateLogic(ModServerConfig config, BlockResolver blockResolver) { + this.config = Objects.requireNonNull(config); + this.blockResolver = Objects.requireNonNull(blockResolver); + } + + public boolean shouldMineFaster(BlockState state) { + return getBlocks().contains(state.getBlock()); + } + + public double miningSpeed() { + return config.miningSpeed(); + } + + public void invalidateBlockCache() { + blocksCache = null; + } + + private Set getBlocks() { + Set cached = blocksCache; + if (cached == null) { + synchronized (this) { + cached = blocksCache; + if (cached == null) { + cached = buildCache(); + blocksCache = cached; + } + } + } + return cached; + } + + private Set buildCache() { + HashSet blocks = new HashSet<>(); + + for (String name : config.blocks()) { + if (name.startsWith("#")) { + cacheBlockTag(blocks, name.substring(1)); + } else { + cacheBlock(blocks, name); + } + } + + if (blocks.isEmpty()) { + Constants.LOGGER.warn("No valid blocks found"); + } else { + Constants.LOGGER.info("Cached {} blocks", blocks.size()); + } + + return Set.copyOf(blocks); + } + + private void cacheBlock(Set blocks, String blockName) { + ResourceLocation id = ResourceLocation.tryParse(blockName); + if (id == null) { + return; + } + + blockResolver.resolveBlock(id).ifPresentOrElse( + block -> { + Constants.LOGGER.debug("Caching block: {}{}", blockName, blocks.contains(block) ? " (DUPLICATED)" : ""); + blocks.add(block); + }, + () -> Constants.LOGGER.warn("Unknown block in config: {}", blockName) + ); + } + + private void cacheBlockTag(Set blocks, String blockTagName) { + ResourceLocation id = ResourceLocation.tryParse(blockTagName); + if (id == null) { + return; + } + + blockResolver.resolveTag(id).ifPresentOrElse( + taggedBlocks -> { + for (Block block : taggedBlocks) { + Constants.LOGGER.debug( + "Caching block from tag #{}: {}{}", + blockTagName, + blockResolver.blockName(block), + blocks.contains(block) ? " (DUPLICATED)" : "" + ); + blocks.add(block); + } + }, + () -> Constants.LOGGER.warn("Unknown block tag in config: #{}", blockTagName) + ); + } + + public interface BlockResolver { + Optional resolveBlock(ResourceLocation id); + Optional> resolveTag(ResourceLocation id); + String blockName(Block block); + } +} diff --git a/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/ModMain.java b/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/ModMain.java index fc5e9c2..7c82ced 100644 --- a/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/ModMain.java +++ b/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/ModMain.java @@ -4,8 +4,6 @@ import net.minecraft.resources.ResourceLocation; import net.minecraft.tags.TagKey; import net.minecraft.world.level.block.Block; -import net.minecraft.world.level.block.state.BlockState; -import net.minecraftforge.common.util.Lazy; import net.minecraftforge.event.TagsUpdatedEvent; import net.minecraftforge.event.entity.player.PlayerEvent; import net.minecraftforge.eventbus.api.SubscribeEvent; @@ -16,103 +14,68 @@ import net.minecraftforge.registries.tags.ITag; import net.minecraftforge.registries.tags.ITagManager; -import java.util.HashSet; +import java.util.List; import java.util.Optional; -import java.util.Set; @Mod(Constants.MODID) public class ModMain { - private static Lazy> blocksCache = Lazy.of(ModMain::buildCache); + private static SoftDeepslateLogic logic; public ModMain(FMLJavaModLoadingContext ctx) { Constants.LOGGER.debug(Constants.INITIALIZING, ModUtils.loc("1.20.1-forge")); + logic = new SoftDeepslateLogic(ServerConfig.INSTANCE, new ForgeBlockResolver()); ctx.registerConfig(ModConfig.Type.SERVER, ServerConfig.SPEC); } - private static Set buildCache() { - HashSet blocks = new HashSet<>(); - - for (String name : ServerConfig.BLOCKS.get()) { - if (name.startsWith("#")) { - cacheBlockTag(blocks, name.substring(1)); - } else { - cacheBlock(blocks, name); + @Mod.EventBusSubscriber(modid = Constants.MODID) + public static class Subscriber { + @SubscribeEvent + public static void onPlayerBreakSpeed(PlayerEvent.BreakSpeed event) { + SoftDeepslateLogic logic = logic(); + if (logic.shouldMineFaster(event.getState())) { + event.setNewSpeed((float) (event.getNewSpeed() * logic.miningSpeed())); } } - if (blocks.isEmpty()) { - Constants.LOGGER.warn("No valid blocks found"); - } else { - Constants.LOGGER.info("Cached {} blocks", blocks.size()); + @SubscribeEvent + public static void onTagsUpdated(TagsUpdatedEvent event) { + logic().invalidateBlockCache(); } - - return Set.copyOf(blocks); } - private static void cacheBlock(Set blocks, String blockName) { - ResourceLocation id = ResourceLocation.tryParse(blockName); - if (id == null) { - return; + private static SoftDeepslateLogic logic() { + if (logic == null) { + throw new IllegalStateException("SoftDeepslateLogic has not been initialized"); } - - Optional.ofNullable(ForgeRegistries.BLOCKS.getValue(id)).ifPresentOrElse( - block -> { - Constants.LOGGER.debug("Caching block: {}{}", blockName, blocks.contains(block) ? " (DUPLICATED)" : ""); - blocks.add(block); - }, - () -> Constants.LOGGER.warn("Unknown block in config: {}", blockName) - ); + return logic; } - private static void cacheBlockTag(Set blocks, String blockTagName) { - ResourceLocation id = ResourceLocation.tryParse(blockTagName); - if (id == null) { - return; - } - - ITagManager tagManager = ForgeRegistries.BLOCKS.tags(); - if (tagManager == null) { - Constants.LOGGER.warn("Block tag manager is not available: #{}", blockTagName); - return; - } - - TagKey tagKey = tagManager.createTagKey(id); - if (!tagManager.isKnownTagName(tagKey)) { - Constants.LOGGER.warn("Unknown block tag in config: #{}", blockTagName); - return; + private static class ForgeBlockResolver implements SoftDeepslateLogic.BlockResolver { + @Override + public Optional resolveBlock(ResourceLocation id) { + return Optional.ofNullable(ForgeRegistries.BLOCKS.getValue(id)); } - ITag tag = tagManager.getTag(tagKey); - for (Block block : tag) { - ResourceLocation blockId = ForgeRegistries.BLOCKS.getKey(block); - String blockName = blockId != null ? blockId.toString() : "?"; - - Constants.LOGGER.debug( - "Caching block from tag #{}: {}{}", - blockTagName, - blockName, - blocks.contains(block) ? " (DUPLICATED)" : "" - ); - blocks.add(block); - } - } - - public static boolean shouldMineFaster(BlockState state) { - return blocksCache.get().contains(state.getBlock()); - } + @Override + public Optional> resolveTag(ResourceLocation id) { + ITagManager tagManager = ForgeRegistries.BLOCKS.tags(); + if (tagManager == null) { + Constants.LOGGER.warn("Block tag manager is not available: #{}", id); + return Optional.of(List.of()); + } - @Mod.EventBusSubscriber(modid = Constants.MODID) - public static class Subscriber { - @SubscribeEvent - public static void onPlayerBreakSpeed(PlayerEvent.BreakSpeed event) { - if (shouldMineFaster(event.getState())) { - event.setNewSpeed((float) (event.getNewSpeed() * ServerConfig.MINING_SPEED.get())); + TagKey tagKey = tagManager.createTagKey(id); + if (!tagManager.isKnownTagName(tagKey)) { + return Optional.empty(); } + + return Optional.of(tagManager.getTag(tagKey)); } - @SubscribeEvent - public static void onTagsUpdated(TagsUpdatedEvent event) { - blocksCache = Lazy.of(ModMain::buildCache); + @Override + public String blockName(Block block) { + ResourceLocation id = ForgeRegistries.BLOCKS.getKey(block); + return id != null ? id.toString() : "?"; } } } diff --git a/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java b/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java index 528a958..7b73d49 100644 --- a/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java +++ b/1.20.1-forge/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java @@ -5,34 +5,47 @@ import java.util.List; -public class ServerConfig { +public class ServerConfig implements ModServerConfig, ModServerConfigValidator { + public static final ServerConfig INSTANCE = new ServerConfig(); + + private static final List DEFAULT_BLOCKS = List.of( + "minecraft:deepslate", + "#forge:cobblestone/deepslate", + "#forge:ores_in_ground/deepslate", + "#softdeepslate:building_blocks" + ); + private static final ForgeConfigSpec.Builder BUILDER = new ForgeConfigSpec.Builder(); public static ForgeConfigSpec.DoubleValue MINING_SPEED = BUILDER - .comment(""" - Adjusts the mining speed for deepslate. - Given that deepslate is twice as hard as stone, a default value of 2.0 allows it to be mined at the same rate as stone.""") - .defineInRange("miningSpeed", 2.0D, 0.0D, Float.MAX_VALUE); + .comment(ModServerConfigEntries.MINING_SPEED.comment()) + .defineInRange( + ModServerConfigEntries.MINING_SPEED.key(), + ModServerConfigEntries.MINING_SPEED.defaultValue(), + ModServerConfigEntries.MINING_SPEED.min(), + ModServerConfigEntries.MINING_SPEED.max() + ); public static ForgeConfigSpec.ConfigValue> BLOCKS = BUILDER - .comment(""" - List of block IDs or block tags (prefix with #) where this mod adjusts the mining speed. - `/reload` to apply.""") - .defineList("blocks", List.of( - "minecraft:deepslate", - "#forge:cobblestone/deepslate", - "#forge:ores_in_ground/deepslate", - "#softdeepslate:building_blocks" - ), ServerConfig::isValidIdOrTag); - - private static boolean isValidIdOrTag(Object entry) { - return entry instanceof String s && isValidIdOrTag(s); + .comment(ModServerConfigEntries.BLOCKS.comment()) + .defineList(ModServerConfigEntries.BLOCKS.key(), DEFAULT_BLOCKS, INSTANCE::isValidIdOrTag); + + public static final ForgeConfigSpec SPEC = BUILDER.build(); + + private ServerConfig() {} + + @Override + public double miningSpeed() { + return MINING_SPEED.get(); } - private static boolean isValidIdOrTag(String entry) { - String normalized = entry.startsWith("#") ? entry.substring(1) : entry; - return ResourceLocation.tryParse(normalized) != null; + @Override + public List blocks() { + return BLOCKS.get(); } - public static final ForgeConfigSpec SPEC = BUILDER.build(); + @Override + public boolean isValidId(String entry) { + return ResourceLocation.tryParse(entry) != null; + } } diff --git a/26.1-common/src/main/java/net/meatwo310/softdeepslate/SoftDeepslateLogic.java b/26.1-common/src/main/java/net/meatwo310/softdeepslate/SoftDeepslateLogic.java new file mode 100644 index 0000000..2a3336f --- /dev/null +++ b/26.1-common/src/main/java/net/meatwo310/softdeepslate/SoftDeepslateLogic.java @@ -0,0 +1,113 @@ +package net.meatwo310.softdeepslate; + +import net.meatwo310.softdeepslate.config.ModServerConfig; +import net.minecraft.resources.Identifier; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.BlockState; + +import java.util.HashSet; +import java.util.Objects; +import java.util.Optional; +import java.util.Set; + +public final class SoftDeepslateLogic { + private final ModServerConfig config; + private final BlockResolver blockResolver; + private volatile Set blocksCache; + + public SoftDeepslateLogic(ModServerConfig config, BlockResolver blockResolver) { + this.config = Objects.requireNonNull(config); + this.blockResolver = Objects.requireNonNull(blockResolver); + } + + public boolean shouldMineFaster(BlockState state) { + return getBlocks().contains(state.getBlock()); + } + + public double miningSpeed() { + return config.miningSpeed(); + } + + public void invalidateBlockCache() { + blocksCache = null; + } + + private Set getBlocks() { + Set cached = blocksCache; + if (cached == null) { + synchronized (this) { + cached = blocksCache; + if (cached == null) { + cached = buildCache(); + blocksCache = cached; + } + } + } + return cached; + } + + private Set buildCache() { + HashSet blocks = new HashSet<>(); + + for (String name : config.blocks()) { + if (name.startsWith("#")) { + cacheBlockTag(blocks, name.substring(1)); + } else { + cacheBlock(blocks, name); + } + } + + if (blocks.isEmpty()) { + Constants.LOGGER.warn("No valid blocks found"); + } else { + Constants.LOGGER.info("Cached {} blocks", blocks.size()); + } + + return Set.copyOf(blocks); + } + + private void cacheBlock(Set blocks, String blockName) { + Identifier id = Identifier.tryParse(blockName); + if (id == null) { + return; + } + + blockResolver.resolveBlock(id).ifPresentOrElse( + block -> { + Constants.LOGGER.debug("Caching block: {}{}", blockName, blocks.contains(block) ? " (DUPLICATED)" : ""); + blocks.add(block); + }, + () -> Constants.LOGGER.warn("Unknown block in config: {}", blockName) + ); + } + + private void cacheBlockTag(Set blocks, String blockTagName) { + Identifier id = Identifier.tryParse(blockTagName); + if (id == null) { + return; + } + + blockResolver.resolveTag(id).ifPresentOrElse( + taggedBlocks -> { + for (Block block : taggedBlocks) { + Constants.LOGGER.debug( + "Caching block from tag #{}: {}{}", + blockTagName, + blockResolver.blockName(block), + blocks.contains(block) ? " (DUPLICATED)" : "" + ); + blocks.add(block); + } + }, + () -> Constants.LOGGER.warn("Unknown block tag in config: #{}", blockTagName) + ); + } + + public interface BlockResolver { + Optional resolveBlock(Identifier id); + + Optional> resolveTag(Identifier id); + + String blockName(Block block); + } +} diff --git a/26.1-neo/src/main/java/net/meatwo310/softdeepslate/ModMain.java b/26.1-neo/src/main/java/net/meatwo310/softdeepslate/ModMain.java index b7c0bc8..3cdf581 100644 --- a/26.1-neo/src/main/java/net/meatwo310/softdeepslate/ModMain.java +++ b/26.1-neo/src/main/java/net/meatwo310/softdeepslate/ModMain.java @@ -7,101 +7,70 @@ import net.minecraft.resources.ResourceKey; import net.minecraft.tags.TagKey; import net.minecraft.world.level.block.Block; -import net.minecraft.world.level.block.state.BlockState; import net.neoforged.bus.api.IEventBus; import net.neoforged.bus.api.SubscribeEvent; import net.neoforged.fml.ModContainer; import net.neoforged.fml.common.EventBusSubscriber; import net.neoforged.fml.common.Mod; import net.neoforged.fml.config.ModConfig; -import net.neoforged.neoforge.common.util.Lazy; import net.neoforged.neoforge.event.TagsUpdatedEvent; import net.neoforged.neoforge.event.entity.player.PlayerEvent; -import java.util.HashSet; -import java.util.Set; +import java.util.Optional; @Mod(Constants.MODID) public class ModMain { - private static final Lazy> blocksCache = Lazy.of(ModMain::buildCache); + private static SoftDeepslateLogic logic; public ModMain(IEventBus modEventBus, ModContainer modContainer) { Constants.LOGGER.debug(Constants.INITIALIZING, ModUtils.id("26.1-neo")); + logic = new SoftDeepslateLogic(ServerConfig.INSTANCE, new NeoBlockResolver()); modContainer.registerConfig(ModConfig.Type.SERVER, ServerConfig.SPEC); } - private static Set buildCache() { - HashSet blocks = new HashSet<>(); - - for (String name : ServerConfig.BLOCKS.get()) { - if (name.startsWith("#")) { - cacheBlockTag(blocks, name.substring(1)); - } else { - cacheBlock(blocks, name); + @EventBusSubscriber(modid = Constants.MODID) + public static class Subscriber { + @SubscribeEvent + public static void onPlayerBreakSpeed(PlayerEvent.BreakSpeed event) { + SoftDeepslateLogic logic = logic(); + if (logic.shouldMineFaster(event.getState())) { + event.setNewSpeed((float) (event.getNewSpeed() * logic.miningSpeed())); } } - if (blocks.isEmpty()) { - Constants.LOGGER.warn("No valid blocks found"); - } else { - Constants.LOGGER.info("Cached {} blocks", blocks.size()); + @SubscribeEvent + public static void onTagsUpdated(TagsUpdatedEvent event) { + logic().invalidateBlockCache(); } - - return Set.copyOf(blocks); } - private static void cacheBlock(Set blocks, String blockName) { - Identifier id = Identifier.tryParse(blockName); - if (id == null) { - return; + private static SoftDeepslateLogic logic() { + if (logic == null) { + throw new IllegalStateException("SoftDeepslateLogic has not been initialized"); } - - BuiltInRegistries.BLOCK.getOptional(id).ifPresentOrElse( - block -> { - Constants.LOGGER.debug("Caching block: {}{}", blockName, blocks.contains(block) ? " (DUPLICATED)" : ""); - blocks.add(block); - }, - () -> Constants.LOGGER.warn("Unknown block in config: {}", blockName) - ); + return logic; } - private static void cacheBlockTag(Set blocks, String blockTagName) { - Identifier id = Identifier.tryParse(blockTagName); - if (id == null) { - return; + private static class NeoBlockResolver implements SoftDeepslateLogic.BlockResolver { + @Override + public Optional resolveBlock(Identifier id) { + return BuiltInRegistries.BLOCK.getOptional(id); } - TagKey tagKey = TagKey.create(Registries.BLOCK, id); - BuiltInRegistries.BLOCK.get(tagKey).ifPresentOrElse( - holders -> holders.forEach(holder -> { - Block block = holder.value(); - String blockName = holder.unwrapKey() - .map(ResourceKey::identifier) - .map(Identifier::toString) - .orElse("?"); - Constants.LOGGER.debug("Caching block from tag #{}: {}{}", blockTagName, blockName, blocks.contains(block) ? " (DUPLICATED)" : ""); - blocks.add(block); - }), - () -> Constants.LOGGER.warn("Unknown block tag in config: #{}", blockTagName) - ); - } - - public static boolean shouldMineFaster(BlockState state) { - return blocksCache.get().contains(state.getBlock()); - } - - @EventBusSubscriber(modid = Constants.MODID) - public static class Subscriber { - @SubscribeEvent - public static void onPlayerBreakSpeed(PlayerEvent.BreakSpeed event) { - if (shouldMineFaster(event.getState())) { - event.setNewSpeed((float) (event.getNewSpeed() * ServerConfig.MINING_SPEED.get())); - } + @Override + public Optional> resolveTag(Identifier id) { + TagKey tagKey = TagKey.create(Registries.BLOCK, id); + return BuiltInRegistries.BLOCK.get(tagKey).map(holders -> holders.stream() + .map(holder -> holder.value()) + .toList()); } - @SubscribeEvent - public static void onTagsUpdated(TagsUpdatedEvent event) { - blocksCache.invalidate(); + @Override + public String blockName(Block block) { + return BuiltInRegistries.BLOCK.getResourceKey(block) + .map(ResourceKey::identifier) + .map(Identifier::toString) + .orElse("?"); } } } diff --git a/26.1-neo/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java b/26.1-neo/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java index 36d522c..ecc40e8 100644 --- a/26.1-neo/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java +++ b/26.1-neo/src/main/java/net/meatwo310/softdeepslate/config/ServerConfig.java @@ -5,34 +5,45 @@ import java.util.List; -public class ServerConfig { +public class ServerConfig implements ModServerConfig, ModServerConfigValidator { + public static final ServerConfig INSTANCE = new ServerConfig(); + private static final ModConfigSpec.Builder BUILDER = new ModConfigSpec.Builder(); public static ModConfigSpec.DoubleValue MINING_SPEED = BUILDER - .comment(""" - Adjusts the mining speed for deepslate. - Given that deepslate is twice as hard as stone, a default value of 2.0 allows it to be mined at the same rate as stone.""") - .defineInRange("miningSpeed", 2.0D, 0.0D, Float.MAX_VALUE); + .comment(ModServerConfigEntries.MINING_SPEED.comment()) + .defineInRange( + ModServerConfigEntries.MINING_SPEED.key(), + ModServerConfigEntries.MINING_SPEED.defaultValue(), + ModServerConfigEntries.MINING_SPEED.min(), + ModServerConfigEntries.MINING_SPEED.max() + ); public static ModConfigSpec.ConfigValue> BLOCKS = BUILDER - .comment(""" - List of block IDs or block tags (prefix with #) where this mod adjusts the mining speed. - `/reload` to apply.""") - .defineList("blocks", List.of( - "minecraft:deepslate", - "#c:cobblestones/deepslate", - "#c:ores_in_ground/deepslate", - "#softdeepslate:building_blocks" - ), () -> "", ServerConfig::isValidIdOrTag); - - private static boolean isValidIdOrTag(Object entry) { - return entry instanceof String s && isValidIdOrTag(s); + .comment(ModServerConfigEntries.BLOCKS.comment()) + .defineList( + ModServerConfigEntries.BLOCKS.key(), + ModServerConfigEntries.BLOCKS.defaultValue(), + ModServerConfigEntries.BLOCKS::newElementValue, + INSTANCE::isValidIdOrTag + ); + + public static final ModConfigSpec SPEC = BUILDER.build(); + + private ServerConfig() {} + + @Override + public double miningSpeed() { + return MINING_SPEED.get(); } - private static boolean isValidIdOrTag(String entry) { - String normalized = entry.startsWith("#") ? entry.substring(1) : entry; - return Identifier.tryParse(normalized) != null; + @Override + public List blocks() { + return BLOCKS.get(); } - public static final ModConfigSpec SPEC = BUILDER.build(); + @Override + public boolean isValidId(String entry) { + return Identifier.tryParse(entry) != null; + } } diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigEntry.java new file mode 100644 index 0000000..30ceff9 --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigEntry.java @@ -0,0 +1,7 @@ +package net.meatwo310.mdk.config; + +public interface ConfigEntry { + String key(); + T defaultValue(); + String comment(); +} diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigEnumEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigEnumEntry.java new file mode 100644 index 0000000..040a577 --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigEnumEntry.java @@ -0,0 +1,7 @@ +package net.meatwo310.mdk.config; + +public record ConfigEnumEntry>( + String key, + E defaultValue, + String comment +) implements ConfigEntry {} diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigInListEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigInListEntry.java new file mode 100644 index 0000000..6e433a6 --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigInListEntry.java @@ -0,0 +1,10 @@ +package net.meatwo310.mdk.config; + +import java.util.List; + +public record ConfigInListEntry( + String key, + T defaultValue, + List allowedValues, + String comment +) implements ConfigEntry {} diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigListEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigListEntry.java new file mode 100644 index 0000000..4492717 --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigListEntry.java @@ -0,0 +1,10 @@ +package net.meatwo310.mdk.config; + +import java.util.List; + +public record ConfigListEntry( + String key, + List defaultValue, + T newElementValue, + String comment +) implements ConfigEntry> {} diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigRangeEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigRangeEntry.java new file mode 100644 index 0000000..021d3fb --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigRangeEntry.java @@ -0,0 +1,9 @@ +package net.meatwo310.mdk.config; + +public record ConfigRangeEntry>( + String key, + T defaultValue, + T min, + T max, + String comment +) implements ConfigEntry {} diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigSimpleEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigSimpleEntry.java new file mode 100644 index 0000000..73b530a --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigSimpleEntry.java @@ -0,0 +1,7 @@ +package net.meatwo310.mdk.config; + +public record ConfigSimpleEntry( + String key, + T defaultValue, + String comment +) implements ConfigEntry {} diff --git a/common/src/main/java/net/meatwo310/mdk/config/ConfigValidatedEntry.java b/common/src/main/java/net/meatwo310/mdk/config/ConfigValidatedEntry.java new file mode 100644 index 0000000..1315863 --- /dev/null +++ b/common/src/main/java/net/meatwo310/mdk/config/ConfigValidatedEntry.java @@ -0,0 +1,10 @@ +package net.meatwo310.mdk.config; + +import java.util.function.Predicate; + +public record ConfigValidatedEntry( + String key, + T defaultValue, + Predicate validator, + String comment +) implements ConfigEntry {} diff --git a/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfig.java b/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfig.java new file mode 100644 index 0000000..7f931cd --- /dev/null +++ b/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfig.java @@ -0,0 +1,8 @@ +package net.meatwo310.softdeepslate.config; + +import java.util.List; + +public interface ModServerConfig { + double miningSpeed(); + List blocks(); +} diff --git a/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfigEntries.java b/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfigEntries.java new file mode 100644 index 0000000..0c86fdb --- /dev/null +++ b/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfigEntries.java @@ -0,0 +1,34 @@ +package net.meatwo310.softdeepslate.config; + +import net.meatwo310.mdk.config.ConfigListEntry; +import net.meatwo310.mdk.config.ConfigRangeEntry; + +import java.util.List; + +public final class ModServerConfigEntries { + public static final ConfigRangeEntry MINING_SPEED = new ConfigRangeEntry<>( + "miningSpeed", + 2.0D, + 0.0D, + (double) Float.MAX_VALUE, + """ + Adjusts the mining speed for deepslate. + Given that deepslate is twice as hard as stone, a default value of 2.0 allows it to be mined at the same rate as stone.""" + ); + + public static final ConfigListEntry BLOCKS = new ConfigListEntry<>( + "blocks", + List.of( + "minecraft:deepslate", + "#c:cobblestones/deepslate", + "#c:ores_in_ground/deepslate", + "#softdeepslate:building_blocks" + ), + "", + """ + List of block IDs or block tags (prefix with #) where this mod adjusts the mining speed. + `/reload` to apply.""" + ); + + private ModServerConfigEntries() {} +} diff --git a/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfigValidator.java b/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfigValidator.java new file mode 100644 index 0000000..f3de537 --- /dev/null +++ b/common/src/main/java/net/meatwo310/softdeepslate/config/ModServerConfigValidator.java @@ -0,0 +1,14 @@ +package net.meatwo310.softdeepslate.config; + +public interface ModServerConfigValidator { + boolean isValidId(String entry); + + default boolean isValidIdOrTag(Object entry) { + return entry instanceof String s && isValidIdOrTag(s); + } + + default boolean isValidIdOrTag(String entry) { + String normalized = entry.startsWith("#") ? entry.substring(1) : entry; + return isValidId(normalized); + } +}